The cl-buchberger Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The cl-buchberger Reference Manual

This is the cl-buchberger Reference Manual, version 0.0.4, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Jun 15 03:32:35 2022 GMT+0.

Table of Contents


1 Introduction

cl-buchberger
=============
Juan M. Bello Rivas 
June 2009

image::images/cl-buchberger.png[Screenshot]

Overview
--------

cl-buchberger is a Common Lisp implementation of Buchberger's
algorithm for the computation of Gröbner bases.

Currently this package can compute Gröbner bases of ideals in
multivariate polynomial rings over the rationals.

Availability
------------

Download the latest version of this package from
http://github.com/jmbr/cl-buchberger/tarball/master

Portability
-----------

The code has been tested under

1. ABCL 0.16.0-dev
2. CLISP 2.47
3. ECL 9.6.1
4. SBCL 1.0.29

License
-------

cl-buchberger is released under the GNU GPLv2.

Usage
-----

Loading the package
~~~~~~~~~~~~~~~~~~~

You need ASDF installed in your system.  To load cl-buchberger,
write:

------------------------------------------------------
  CL-USER> (asdf:operate 'asdf:load-op :cl-buchberger)
  NIL
  CL-USER> (use-package :cl-buchberger)
  T
------------------------------------------------------

Defining a polynomial ring
~~~~~~~~~~~~~~~~~~~~~~~~~~

There's a default ring which is the ring of polynomials on X, Y, Z
over the rationals.  To define custom polynomial rings use:

---------------------------------------------------------
  CL-USER> (make-instance 'polynomial-ring :variables
                          (list 'x 'y 'z 'u 'w 'r 's 't))
  #
---------------------------------------------------------

To change the default ring just bind \*RING\* to whatever you want:

---------------------------------------------------------------------
  CL-USER> (defparameter *ring*
             (make-instance 'polynomial-ring :variables (list 'x 'y))
             "QQ[X, Y]")
  *RING*
  CL-USER> *ring*
  #
---------------------------------------------------------------------

Defining polynomials
~~~~~~~~~~~~~~~~~~~~

Polynomials are defined using a list of terms where each term is a
list with the coefficient as its first term and where the remaining
elements are variable exponents.  For example: (1 1 2 3) would
correspond to the term $$`xy^2z^3`$$

Thus, to create a polynomial write:

-------------------------------------------------------------------
  CL-USER> (defparameter *l* (make-polynomial '((1 3 0) (-2 1 1))))
  *L*
  CL-USER> *l*
  #
  CL-USER> (defparameter *m* (make-polynomial '((3 4 1) (1 2 0))))
  *M*
  CL-USER> *m*
  #
-------------------------------------------------------------------

Polynomial arithmetic
~~~~~~~~~~~~~~~~~~~~~

Use the generic functions RING+, RING-, RING*, and RING/ for the usual
arithmetic operations.

The function RING/ is the multivariate polynomial division algorithm
and takes a polynomial and a sequence of divisors to produce a
sequence of quotients and a remainder.

To set the default monomial ordering, bind \*MONOMIAL-ORDERING\* to the
relevant function (which defaults to LEX>).  For example:

--------------------------------------------------------
  CL-USER> (defparameter *monomial-ordering* #'grevlex>)
  *MONOMIAL-ORDERING*
--------------------------------------------------------

Also, you can use the macro WITH-MONOMIAL-ORDERING to define the
current monomial ordering as in:

-------------------------------------------
  CL-USER> (with-monomial-ordering #'grlex>
             (ring/ *m* *l*))
  #(#)
  #
-------------------------------------------

Computing Gröbner bases
~~~~~~~~~~~~~~~~~~~~~~~

The functions GROEBNER and REDUCED-GROEBNER compute Gröbner bases and
reduced Gröbner bases respectively.  Both of them take a sequence of
polynomials as parameter.  An alternative is to construct a polynomial
ideal and obtain its reduced Gröbner basis using the BASIS generic
function.

For example:

--------------------------------------------------------------------------------
  CL-USER> (defparameter *katsura-3*
             (make-ideal (list (make-polynomial '((1 1 0 0) (2 0 1 0) (2 0 0 1) (-1 0 0 0)))
                               (make-polynomial '((1 2 0 0) (-1 1 0 0) (2 0 2 0) (2 0 0 2)))
                               (make-polynomial '((2 1 1 0) (2 0 1 1) (-1 0 1 0)))))
             "Katsura-3 over QQ[x, y, z] (default ring)")
  *KATSURA-3*
  CL-USER> *katsura-3*
  # :GENERATORS #(#
                                            #
                                            #)>
  CL-USER> (basis *katsura-3*)
  #(#
    #
    #)
--------------------------------------------------------------------------------

Bug reports
-----------

There's a bug tracker available at http://github.com/jmbr/cl-buchberger/issues


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 cl-buchberger

cl-buchberger: A Common Lisp implementation of Buchberger’s algorithm.

Author

Juan M. Bello Rivas <jmbr@superadditive.com>

License

GNU GPLv2

Version

0.0.4

Source

cl-buchberger.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 cl-buchberger/cl-buchberger.asd

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

ASDF Systems

cl-buchberger.

Packages

com.superadditive.cl-buchberger-system.


3.1.2 cl-buchberger/package.lisp

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Packages

com.superadditive.cl-buchberger.


3.1.3 cl-buchberger/vector.lisp

Dependency

package.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Internals

3.1.4 cl-buchberger/ring.lisp

Dependency

vector.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Internals

ring (class).


3.1.5 cl-buchberger/ring-element.lisp

Dependency

ring.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

3.1.6 cl-buchberger/term.lisp

Dependency

ring-element.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

3.1.7 cl-buchberger/monomial-orderings.lisp

Dependency

term.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface

3.1.8 cl-buchberger/polynomial-ring.lisp

Dependency

monomial-orderings.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

3.1.9 cl-buchberger/polynomial.lisp

Dependency

polynomial-ring.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

3.1.10 cl-buchberger/arithmetic.lisp

Dependency

polynomial.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

3.1.11 cl-buchberger/groebner.lisp

Dependency

arithmetic.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

3.1.12 cl-buchberger/ideal.lisp

Dependency

groebner.lisp (file).

Source

cl-buchberger.asd.

Parent Component

cl-buchberger (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


4.1 com.superadditive.cl-buchberger-system

Source

cl-buchberger.asd.

Use List
  • asdf/interface.
  • common-lisp.

4.2 com.superadditive.cl-buchberger

Source

package.lisp.

Nickname

cl-buchberger

Use List
  • asdf/interface.
  • common-lisp.
Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.1 Special variables

Special Variable: *monomial-ordering*

Specifies the ordering of monomials in a polynomial

Package

com.superadditive.cl-buchberger.

Source

monomial-orderings.lisp.

Special Variable: *ring*

Default polynomial ring

Package

com.superadditive.cl-buchberger.

Source

polynomial-ring.lisp.


5.1.2 Macros

Macro: doterms ((var poly &optional resultform) &body body)
Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Macro: with-monomial-ordering (ordering &body body)
Package

com.superadditive.cl-buchberger.

Source

monomial-orderings.lisp.

Macro: with-polynomial-ring (ring &body body)
Package

com.superadditive.cl-buchberger.

Source

polynomial-ring.lisp.


5.1.3 Ordinary functions

Function: degree (m)

Returns the total degree of a monomial

Package

com.superadditive.cl-buchberger.

Source

monomial-orderings.lisp.

Function: grevlex> (m1 m2)

Graded Reverse Lex Order

Package

com.superadditive.cl-buchberger.

Source

monomial-orderings.lisp.

Function: grlex> (m1 m2)

Graded Lex Order

Package

com.superadditive.cl-buchberger.

Source

monomial-orderings.lisp.

Function: groebner (polynomials)

Returns a Groebner basis for the ideal generated by the specified array of polynomials.

Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: lex> (m1 m2)

Lexicographic Order

Package

com.superadditive.cl-buchberger.

Source

monomial-orderings.lisp.

Function: make-ideal (generators)

Create a new ideal generated by the elements contained in the ‘generators’ list.

Package

com.superadditive.cl-buchberger.

Source

ideal.lisp.

Function: make-polynomial (term-list &key ring)
Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Function: mapterm (function polynomial)

Apply FUNCTION to successive terms of POLYNOMIAL. Return list of FUNCTION return values.

Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Function: reduce-gb (g)

Returns a reduced Groebner basis.

Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: reduced-groebner (f)

Computes and reduces a Groebner basis of the ideal generated by F.

Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: s-poly (f g)

Returns the S-polynomial of f and g

Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.


5.1.4 Generic functions

Generic Function: basis (ideal)

Returns an array of generators for ‘ideal’.

Package

com.superadditive.cl-buchberger.

Source

ideal.lisp.

Methods
Method: basis ((ideal ideal))
Generic Function: lc (poly)

Returns the leading coefficient of a polynomial

Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Methods
Method: lc ((poly polynomial))
Generic Function: lm (poly)

Returns the leading monomial of a polynomial. That is, the leading term with 1 as coefficient

Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Methods
Method: lm ((poly polynomial))
Generic Function: lt (poly)

Returns the leading term of a polynomial.

Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Methods
Method: lt ((poly polynomial))
Generic Function: member-p (element ideal)
Package

com.superadditive.cl-buchberger.

Source

ideal.lisp.

Methods
Method: member-p ((element ring-element) (ideal ideal))
Generic Function: multideg (poly)

Returns the multidegree of a polynomial

Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Methods
Method: multideg ((poly polynomial))
Generic Function: ring* (element &rest more-elements)
Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring* ((poly polynomial) &rest more-polynomials)
Source

arithmetic.lisp.

Generic Function: ring+ (element &rest more-elements)
Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring+ ((poly polynomial) &rest more-polynomials)
Source

arithmetic.lisp.

Generic Function: ring- (element &rest more-elements)
Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring- ((poly polynomial) &rest more-polynomials)
Source

arithmetic.lisp.

Generic Function: ring-equal-p (e1 e2)

Returns t if e1 equals e2, nil otherwise

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring-equal-p ((t1 term) (t2 term))
Source

term.lisp.

Generic Function: ring-identity-p (element)

Returns t if element is the multiplicative identity, nil otherwise

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Generic Function: ring-lcm (e1 e2)

Returns the LCM of e1 and e2

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring-lcm ((r1 rational) (r2 rational))

LCM over the rationals.

Source

arithmetic.lisp.

Method: ring-lcm ((t1 term) (t2 term))

Returns LCM(t1, t2)

Source

arithmetic.lisp.

Generic Function: ring-zero-p (element)

Returns t if element is zero, nil otherwise

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring-zero-p ((poly polynomial))
Source

polynomial.lisp.

Method: ring-zero-p ((tm term))
Source

term.lisp.

Generic Function: ring/ (element &rest more-elements)
Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring/ ((poly polynomial) &rest more-polynomials)
Source

arithmetic.lisp.


5.1.5 Standalone methods

Method: initialize-instance :after ((ring polynomial-ring) &key)
Source

polynomial-ring.lisp.

Method: initialize-instance :after ((tm term) &key ring)
Source

term.lisp.

Method: print-object ((p polynomial) stream)
Source

polynomial.lisp.

Method: print-object ((ring polynomial-ring) stream)
Source

polynomial-ring.lisp.

Method: print-object ((ideal ideal) stream)
Source

ideal.lisp.

Method: print-object ((tm term) stream)
Source

term.lisp.


5.1.6 Classes

Class: polynomial
Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Direct superclasses

ring-element.

Direct methods
Direct slots
Slot: base-ring
Initform

(error "you must specify a base ring")

Initargs

:ring

Readers

base-ring.

Writers

(setf base-ring).

Slot: terms
Type

hash-table

Initform

(make-hash-table :test (function equalp))

Initargs

:terms

Readers

terms.

Writers

(setf terms).

Class: polynomial-ring
Package

com.superadditive.cl-buchberger.

Source

polynomial-ring.lisp.

Direct superclasses

ring.

Direct methods
Direct slots
Slot: variables
Initform

(error "you must specify at least one variable")

Initargs

:variables

Readers

variables.

Writers

This slot is read-only.

Slot: base-field
Initform

(quote rational)

Initargs

:base-field

Readers

base-field.

Writers

This slot is read-only.


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Ordinary functions

Function: criterion (g b i j fi fj)

Returns t if S_{ij} has to be considered

Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: make-index-set (s)
Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: normal-form (f g)
Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: pair-member (l m b)
Package

com.superadditive.cl-buchberger.

Source

groebner.lisp.

Function: terms->list (poly)
Package

com.superadditive.cl-buchberger.

Source

polynomial.lisp.

Function: vector+ (v1 v2)

Returns the sum of the two vectors V1 and V2.

Package

com.superadditive.cl-buchberger.

Source

vector.lisp.

Function: vector- (v1 v2)

Returns the difference of the two vectors V1 and V2.

Package

com.superadditive.cl-buchberger.

Source

vector.lisp.

Function: vector-zero-p (v)

Returns T if every compoment in V is zero.

Package

com.superadditive.cl-buchberger.

Source

vector.lisp.

Function: vector= (v1 v2)

Returns T if both vectors V1 and V2 have the same components, NIL otherwise.

Package

com.superadditive.cl-buchberger.

Source

vector.lisp.

Function: vector> (v1 v2)

Returns T if every component in V1 is greater than the corresponding component in V2, NIL otherwise.

Package

com.superadditive.cl-buchberger.

Source

vector.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.2 Generic functions

Generic Function: add (e1 e2)

Adds ring elements

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: add ((p1 polynomial) (p2 polynomial))

Returns the sum of two polynomials

Source

arithmetic.lisp.

Method: add ((poly polynomial) (tm term))

Returns the polynomial with the added term

Source

arithmetic.lisp.

Generic Reader: base-field (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: base-field ((polynomial-ring polynomial-ring))

automatically generated reader method

Source

polynomial-ring.lisp.

Target Slot

base-field.

Generic Reader: base-ring (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: base-ring ((polynomial polynomial))

automatically generated reader method

Source

polynomial.lisp.

Target Slot

base-ring.

Generic Writer: (setf base-ring) (object)
Package

com.superadditive.cl-buchberger.

Methods
Writer Method: (setf base-ring) ((polynomial polynomial))

automatically generated writer method

Source

polynomial.lisp.

Target Slot

base-ring.

Generic Reader: coefficient (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: coefficient ((term term))

automatically generated reader method

Source

term.lisp.

Target Slot

coefficient.

Generic Writer: (setf coefficient) (object)
Package

com.superadditive.cl-buchberger.

Methods
Writer Method: (setf coefficient) ((term term))

automatically generated writer method

Source

term.lisp.

Target Slot

coefficient.

Generic Function: div (e1 e2)

Divides ring elements

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: div ((t1 term) (t2 term))

Returns the quotient of two terms

Source

arithmetic.lisp.

Generic Function: divides-p (e1 e2)

Returns t if e1 divides e2 in the base ring

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: divides-p ((t1 term) (p polynomial))
Source

arithmetic.lisp.

Method: divides-p ((t1 term) (t2 term))
Source

arithmetic.lisp.

Generic Function: divmod (element divisors)

Returns quotient(s) and remainder if we are working in an Euclidean ring.

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: divmod ((f polynomial) fs)

Divides F by the polynomials in the sequence FS and returns the quotients (as an array) and a remainder.

Source

arithmetic.lisp.

Generic Function: element->string (element &key ring leading-term &allow-other-keys)

Returns a human-readable string representation of an element

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: element->string ((poly polynomial) &key)
Source

polynomial.lisp.

Method: element->string ((tm term) &key ring leading-term)
Source

term.lisp.

Generic Reader: generators (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: generators ((ideal ideal))

automatically generated reader method

Source

ideal.lisp.

Target Slot

generators.

Generic Writer: (setf generators) (object)
Package

com.superadditive.cl-buchberger.

Methods
Writer Method: (setf generators) ((ideal ideal))

automatically generated writer method

Source

ideal.lisp.

Target Slot

generators.

Generic Reader: monomial (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: monomial ((term term))

automatically generated reader method

Source

term.lisp.

Target Slot

monomial.

Generic Writer: (setf monomial) (object)
Package

com.superadditive.cl-buchberger.

Methods
Writer Method: (setf monomial) ((term term))

automatically generated writer method

Source

term.lisp.

Target Slot

monomial.

Generic Function: mul (e1 e2)

Multiplies ring elements

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: mul ((p1 polynomial) (p2 polynomial))

Returns the product of two polynomials

Source

arithmetic.lisp.

Method: mul ((poly polynomial) (tm term))

Returns the product of a polynomial by a term

Source

arithmetic.lisp.

Method: mul ((t1 term) (t2 term))

Multiplies two terms storing the result in the first term.

Source

arithmetic.lisp.

Method: mul ((t1 term) (num number))
Source

arithmetic.lisp.

Method: mul ((poly polynomial) (num number))
Source

arithmetic.lisp.

Generic Reader: operands (condition)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: operands ((condition ring-division-by-zero))
Source

ring-element.lisp.

Target Slot

operands.

Generic Reader: ring (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: ring ((ideal ideal))

automatically generated reader method

Source

ideal.lisp.

Target Slot

ring.

Generic Writer: (setf ring) (object)
Package

com.superadditive.cl-buchberger.

Methods
Writer Method: (setf ring) ((ideal ideal))

automatically generated writer method

Source

ideal.lisp.

Target Slot

ring.

Generic Function: ring-copy (element)

Returns a deep copy of an element

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring-copy ((poly polynomial))

Returns a (deep) copy of the given polynomial

Source

polynomial.lisp.

Generic Function: ring-mod (element &rest more-elements)
Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: ring-mod (f &rest fs)
Source

arithmetic.lisp.

Generic Function: sub (e1 e2)

Subtracts ring elements

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Methods
Method: sub ((p1 polynomial) (p2 polynomial))

Returns the result of subtracting two polynomials.

Source

arithmetic.lisp.

Method: sub ((poly polynomial) (tm term))

Returns the result of subtracting the term from the polynomial

Source

arithmetic.lisp.

Generic Reader: terms (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: terms ((polynomial polynomial))

automatically generated reader method

Source

polynomial.lisp.

Target Slot

terms.

Generic Writer: (setf terms) (object)
Package

com.superadditive.cl-buchberger.

Methods
Writer Method: (setf terms) ((polynomial polynomial))

automatically generated writer method

Source

polynomial.lisp.

Target Slot

terms.

Generic Reader: variables (object)
Package

com.superadditive.cl-buchberger.

Methods
Reader Method: variables ((polynomial-ring polynomial-ring))

automatically generated reader method

Source

polynomial-ring.lisp.

Target Slot

variables.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.3 Conditions

Condition: ring-division-by-zero
Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Direct superclasses

error.

Direct methods

operands.

Direct slots
Slot: operands
Initargs

:operands

Readers

operands.

Writers

This slot is read-only.


Previous: , Up: Internals   [Contents][Index]

5.2.4 Classes

Class: ideal
Package

com.superadditive.cl-buchberger.

Source

ideal.lisp.

Direct methods
Direct slots
Slot: ring
Initform

(error "you must specify a ring for the polynomial ideal.")

Initargs

:ring

Readers

ring.

Writers

(setf ring).

Slot: generators
Initform

(error "you must give a set of generators for the ideal.")

Initargs

:generators

Readers

generators.

Writers

(setf generators).

Class: ring

Base class for rings.

Package

com.superadditive.cl-buchberger.

Source

ring.lisp.

Direct subclasses

polynomial-ring.

Class: ring-element

Base class for ring elements.

Package

com.superadditive.cl-buchberger.

Source

ring-element.lisp.

Direct subclasses
Direct methods

member-p.

Direct slots
Slot: base-ring
Class: term
Package

com.superadditive.cl-buchberger.

Source

term.lisp.

Direct superclasses

ring-element.

Direct methods
Direct slots
Slot: coefficient
Initform

0

Initargs

:coefficient

Readers

coefficient.

Writers

(setf coefficient).

Slot: monomial
Type

vector

Initform

#()

Initargs

:monomial

Readers

monomial.

Writers

(setf monomial).


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   I   L   M   N   O   P   R   S   T   V   W  
Index Entry  Section

(
(setf base-ring): Private generic functions
(setf base-ring): Private generic functions
(setf coefficient): Private generic functions
(setf coefficient): Private generic functions
(setf generators): Private generic functions
(setf generators): Private generic functions
(setf monomial): Private generic functions
(setf monomial): Private generic functions
(setf ring): Private generic functions
(setf ring): Private generic functions
(setf terms): Private generic functions
(setf terms): Private generic functions

A
add: Private generic functions
add: Private generic functions
add: Private generic functions

B
base-field: Private generic functions
base-field: Private generic functions
base-ring: Private generic functions
base-ring: Private generic functions
basis: Public generic functions
basis: Public generic functions

C
coefficient: Private generic functions
coefficient: Private generic functions
criterion: Private ordinary functions

D
degree: Public ordinary functions
div: Private generic functions
div: Private generic functions
divides-p: Private generic functions
divides-p: Private generic functions
divides-p: Private generic functions
divmod: Private generic functions
divmod: Private generic functions
doterms: Public macros

E
element->string: Private generic functions
element->string: Private generic functions
element->string: Private generic functions

F
Function, criterion: Private ordinary functions
Function, degree: Public ordinary functions
Function, grevlex>: Public ordinary functions
Function, grlex>: Public ordinary functions
Function, groebner: Public ordinary functions
Function, lex>: Public ordinary functions
Function, make-ideal: Public ordinary functions
Function, make-index-set: Private ordinary functions
Function, make-polynomial: Public ordinary functions
Function, mapterm: Public ordinary functions
Function, normal-form: Private ordinary functions
Function, pair-member: Private ordinary functions
Function, reduce-gb: Public ordinary functions
Function, reduced-groebner: Public ordinary functions
Function, s-poly: Public ordinary functions
Function, terms->list: Private ordinary functions
Function, vector+: Private ordinary functions
Function, vector-: Private ordinary functions
Function, vector-zero-p: Private ordinary functions
Function, vector=: Private ordinary functions
Function, vector>: Private ordinary functions

G
generators: Private generic functions
generators: Private generic functions
Generic Function, (setf base-ring): Private generic functions
Generic Function, (setf coefficient): Private generic functions
Generic Function, (setf generators): Private generic functions
Generic Function, (setf monomial): Private generic functions
Generic Function, (setf ring): Private generic functions
Generic Function, (setf terms): Private generic functions
Generic Function, add: Private generic functions
Generic Function, base-field: Private generic functions
Generic Function, base-ring: Private generic functions
Generic Function, basis: Public generic functions
Generic Function, coefficient: Private generic functions
Generic Function, div: Private generic functions
Generic Function, divides-p: Private generic functions
Generic Function, divmod: Private generic functions
Generic Function, element->string: Private generic functions
Generic Function, generators: Private generic functions
Generic Function, lc: Public generic functions
Generic Function, lm: Public generic functions
Generic Function, lt: Public generic functions
Generic Function, member-p: Public generic functions
Generic Function, monomial: Private generic functions
Generic Function, mul: Private generic functions
Generic Function, multideg: Public generic functions
Generic Function, operands: Private generic functions
Generic Function, ring: Private generic functions
Generic Function, ring*: Public generic functions
Generic Function, ring+: Public generic functions
Generic Function, ring-: Public generic functions
Generic Function, ring-copy: Private generic functions
Generic Function, ring-equal-p: Public generic functions
Generic Function, ring-identity-p: Public generic functions
Generic Function, ring-lcm: Public generic functions
Generic Function, ring-mod: Private generic functions
Generic Function, ring-zero-p: Public generic functions
Generic Function, ring/: Public generic functions
Generic Function, sub: Private generic functions
Generic Function, terms: Private generic functions
Generic Function, variables: Private generic functions
grevlex>: Public ordinary functions
grlex>: Public ordinary functions
groebner: Public ordinary functions

I
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods

L
lc: Public generic functions
lc: Public generic functions
lex>: Public ordinary functions
lm: Public generic functions
lm: Public generic functions
lt: Public generic functions
lt: Public generic functions

M
Macro, doterms: Public macros
Macro, with-monomial-ordering: Public macros
Macro, with-polynomial-ring: Public macros
make-ideal: Public ordinary functions
make-index-set: Private ordinary functions
make-polynomial: Public ordinary functions
mapterm: Public ordinary functions
member-p: Public generic functions
member-p: Public generic functions
Method, (setf base-ring): Private generic functions
Method, (setf coefficient): Private generic functions
Method, (setf generators): Private generic functions
Method, (setf monomial): Private generic functions
Method, (setf ring): Private generic functions
Method, (setf terms): Private generic functions
Method, add: Private generic functions
Method, add: Private generic functions
Method, base-field: Private generic functions
Method, base-ring: Private generic functions
Method, basis: Public generic functions
Method, coefficient: Private generic functions
Method, div: Private generic functions
Method, divides-p: Private generic functions
Method, divides-p: Private generic functions
Method, divmod: Private generic functions
Method, element->string: Private generic functions
Method, element->string: Private generic functions
Method, generators: Private generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, lc: Public generic functions
Method, lm: Public generic functions
Method, lt: Public generic functions
Method, member-p: Public generic functions
Method, monomial: Private generic functions
Method, mul: Private generic functions
Method, mul: Private generic functions
Method, mul: Private generic functions
Method, mul: Private generic functions
Method, mul: Private generic functions
Method, multideg: Public generic functions
Method, operands: Private generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, ring: Private generic functions
Method, ring*: Public generic functions
Method, ring+: Public generic functions
Method, ring-: Public generic functions
Method, ring-copy: Private generic functions
Method, ring-equal-p: Public generic functions
Method, ring-lcm: Public generic functions
Method, ring-lcm: Public generic functions
Method, ring-mod: Private generic functions
Method, ring-zero-p: Public generic functions
Method, ring-zero-p: Public generic functions
Method, ring/: Public generic functions
Method, sub: Private generic functions
Method, sub: Private generic functions
Method, terms: Private generic functions
Method, variables: Private generic functions
monomial: Private generic functions
monomial: Private generic functions
mul: Private generic functions
mul: Private generic functions
mul: Private generic functions
mul: Private generic functions
mul: Private generic functions
mul: Private generic functions
multideg: Public generic functions
multideg: Public generic functions

N
normal-form: Private ordinary functions

O
operands: Private generic functions
operands: Private generic functions

P
pair-member: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods
print-object: Public standalone methods

R
reduce-gb: Public ordinary functions
reduced-groebner: Public ordinary functions
ring: Private generic functions
ring: Private generic functions
ring*: Public generic functions
ring*: Public generic functions
ring+: Public generic functions
ring+: Public generic functions
ring-: Public generic functions
ring-: Public generic functions
ring-copy: Private generic functions
ring-copy: Private generic functions
ring-equal-p: Public generic functions
ring-equal-p: Public generic functions
ring-identity-p: Public generic functions
ring-lcm: Public generic functions
ring-lcm: Public generic functions
ring-lcm: Public generic functions
ring-mod: Private generic functions
ring-mod: Private generic functions
ring-zero-p: Public generic functions
ring-zero-p: Public generic functions
ring-zero-p: Public generic functions
ring/: Public generic functions
ring/: Public generic functions

S
s-poly: Public ordinary functions
sub: Private generic functions
sub: Private generic functions
sub: Private generic functions

T
terms: Private generic functions
terms: Private generic functions
terms->list: Private ordinary functions

V
variables: Private generic functions
variables: Private generic functions
vector+: Private ordinary functions
vector-: Private ordinary functions
vector-zero-p: Private ordinary functions
vector=: Private ordinary functions
vector>: Private ordinary functions

W
with-monomial-ordering: Public macros
with-polynomial-ring: Public macros

Jump to:   (  
A   B   C   D   E   F   G   I   L   M   N   O   P   R   S   T   V   W  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   C   F   G   I   M   P   R   S   T   V  
Index Entry  Section

A
arithmetic.lisp: The cl-buchberger/arithmetic․lisp file

C
cl-buchberger: The cl-buchberger system
cl-buchberger.asd: The cl-buchberger/cl-buchberger․asd file
Class, ideal: Private classes
Class, polynomial: Public classes
Class, polynomial-ring: Public classes
Class, ring: Private classes
Class, ring-element: Private classes
Class, term: Private classes
com.superadditive.cl-buchberger: The com․superadditive․cl-buchberger package
com.superadditive.cl-buchberger-system: The com․superadditive․cl-buchberger-system package
Condition, ring-division-by-zero: Private conditions

F
File, arithmetic.lisp: The cl-buchberger/arithmetic․lisp file
File, cl-buchberger.asd: The cl-buchberger/cl-buchberger․asd file
File, groebner.lisp: The cl-buchberger/groebner․lisp file
File, ideal.lisp: The cl-buchberger/ideal․lisp file
File, monomial-orderings.lisp: The cl-buchberger/monomial-orderings․lisp file
File, package.lisp: The cl-buchberger/package․lisp file
File, polynomial-ring.lisp: The cl-buchberger/polynomial-ring․lisp file
File, polynomial.lisp: The cl-buchberger/polynomial․lisp file
File, ring-element.lisp: The cl-buchberger/ring-element․lisp file
File, ring.lisp: The cl-buchberger/ring․lisp file
File, term.lisp: The cl-buchberger/term․lisp file
File, vector.lisp: The cl-buchberger/vector․lisp file

G
groebner.lisp: The cl-buchberger/groebner․lisp file

I
ideal: Private classes
ideal.lisp: The cl-buchberger/ideal․lisp file

M
monomial-orderings.lisp: The cl-buchberger/monomial-orderings․lisp file

P
Package, com.superadditive.cl-buchberger: The com․superadditive․cl-buchberger package
Package, com.superadditive.cl-buchberger-system: The com․superadditive․cl-buchberger-system package
package.lisp: The cl-buchberger/package․lisp file
polynomial: Public classes
polynomial-ring: Public classes
polynomial-ring.lisp: The cl-buchberger/polynomial-ring․lisp file
polynomial.lisp: The cl-buchberger/polynomial․lisp file

R
ring: Private classes
ring-division-by-zero: Private conditions
ring-element: Private classes
ring-element.lisp: The cl-buchberger/ring-element․lisp file
ring.lisp: The cl-buchberger/ring․lisp file

S
System, cl-buchberger: The cl-buchberger system

T
term: Private classes
term.lisp: The cl-buchberger/term․lisp file

V
vector.lisp: The cl-buchberger/vector․lisp file

Jump to:   A   C   F   G   I   M   P   R   S   T   V