Gröbner Bases with Reduction Machines
MM. Marin, A. Cr˘aciun (Eds.):Working Formal Methods Symposium 2019 (FROM 2019)EPTCS 303, 2019, pp. 61–75, doi:10.4204/EPTCS.303.5 c (cid:13)
G. S¸ urlea & A. Cr˘aciunThis work is licensed under theCreative Commons Attribution License.
Gr ¨obner Bases with Reduction Machines
Georgiana S¸ urlea
Department of Computer ScienceWest UniversityTimis¸oara, Romania [email protected]
Adrian Cr˘aciun ∗ Department of Computer ScienceWest UniversityTimis¸oara, RomaniaInstitute E-Austria Timis¸oara [email protected]
In this paper, we make a contribution to the computation of Gr¨obner bases. For polynomial reduction,instead of choosing the leading monomial of a polynomial as the monomial with respect to whichthe reduction process is carried out, we investigate what happens if we make that choice arbitrarily.It turns out not only this is possible (the fact that this produces a normal form being already knownin the literature), but, for a fixed choice of reductors, the obtained normal form is the same no matterthe order in which we reduce the monomials.To prove this, we introduce reduction machines, which work by reducing each monomial in-dependently and then collecting the result. We show that such a machine can simulate any suchreduction. We then discuss different implementations of these machines. Some of these implemen-tations address inherent inefficiencies in reduction machines (repeating the same computations). Wedescribe a first implementation and look at some experimental results.
The concept of Gr¨obner bases, together with an algorithm for the computation of Gr¨obner bases, intro-duced by Buchberger in [8], represents an important contribution to symbolic computation. There aremany applications of Gr¨obner bases computations, e.g. solving systems of polynomial equations, theo-rem proving in geometry, software and hardware verification, robotics, coding theory, oil extraction, etc.Descriptions of the applications of Gr¨obner bases can be found for example in [6], [9].
We have a set of objects (multivariate polynomials over a field), together with a reduction relation → F ,generated by a set F (of ”generators” for a polynomial ideal). The reduction relation is terminating.This induces a notion (and algorithm) for computing the reduced normal form of a polynomial s w.r.t F , Red ( s , F ) .We want to solve a (variant of the) word problem : decide whether a polynomial belongs to the idealgenerated by F . For this, using Buchberger’s algorithm (Algorithm 1), we can construct G , a finite setof polynomials that generates the same ideal as F . The set G is called a Gr¨obner basis and it makes theideal membership test easy.A Gr¨obner basis G is characterized by the fact that certain critical polynomials , built from pairsof polynomials in G – the S-polynomials (computed by a function Spol ) – can be reduced to zero, i.e.
Red ( Spol ( f , g ) , G ) = ∗ Supported by ATCO, “Advanced techniques in combinatorial optimization and computational complexity”, CNCS IDEIGrant PN-III-P4-ID-PCE-2016-0842. Gr¨obner Bases with Reduction Machines
Algorithm 1 (Buchberger’s algorithm for computing Gr¨obner bases) . Input : F a finite set of polynomials .Output : G a finite Gr¨obner basis equivalent to FG := FC := G × G while C (cid:54) = doChoose a pair ( f , g ) ∈ CC := C \ { ( f , g ) } h := Red ( Spol ( f , g ) , G ) if h (cid:54) = then C := C ∪ ( G × { h } ) G := G ∪ { h } return G Due to the high complexity of the problem (double exponential in the worst case, see [16]), there havebeen (and are continuing) efforts for improving performance. We outline some of them here.
Criteria to avoid useless reductions have been proposed by Buchberger in [4].
Reduced Gr¨obnerbases were proposed in [5]: polynomials in the basis being constructed (before the start of the algorithm),as well as before adding new polynomials to the basis, should be reduced among each other in order toeliminate redundant polynomials in the basis.The algorithm for computing Gr¨obner bases leaves some choices open.
Which critical pair shouldbe selected – simple criteria like minimal degree for the least common multiple of the components wereproposed in [5], as well as more sophisticated ones like the ”sugar” strategy, see [14].
Which elementfrom the basis is chosen for the current reduction step – a discussion of the possible choices can be foundin [17].Further improvements looked at combining techniques from linear algebra to allow multiple reduc-tions of S-polynomials, e.g. the F4 [11] and F5 [12] algorithms, or techniques from partial differentialequations together with a restriction of the notion of reduction to construct involutive bases containingGr¨obner bases, see [13], also [2].
Our focus in this paper is the basic process of reducing a polynomial modulo a set of polynomials, whichis the most time consuming part in the execution of the Gr¨obner bases algorithm. Traditionally, forthe polynomial being reduced, one selects the leading monomial (w.r.t. some admissible ordering) andreduces it (in a while loop, for each such situation).What would happen if we choose a different monomial? Would reduction work? Yes, a normal formwould be computed. Moreover, in certain conditions (if we keep the choice of reductors, i.e. the selectionstrategy), no matter the choice of the monomial, we get the same normal form. Would different choiceslead to a faster solution? Probably not, but sometimes it can be done just as fast. However, this line ofinquiry led to what turns out to be a parallel method to do reduction, which has the potential to improvethe performance.Our paper is organized as follows. Section 2 provides the basic concepts needed, including standardreduction. In Section 3 we introduce reduction processes , objects that express all possible ways in whichwe can perform reductions. In Section 4 we introduce reduction machines and prove that for a fixed . S¸ urlea & A. Cr˘aciun
Since the focus of this paper is reduction, we recall some relevant notions. For this we use the notationand definitions from [6]. For the complete details, we refer the reader to standard textbook presentationsof Gr¨obner bases, e.g. [6], [3], etc. ( K , + , , − , · , , / ) a field , K [ x , . . . , x n ] the ring of n -variate polynomials over K , [ x , . . . , x n ] power products over x , . . . , x n , f , g , h , p , q , s polynomials in K [ x , . . . , x n ] , F , G finite subsets of K [ x , . . . , x n ] , m monomials, t , u , pp power products from [ x , . . . , x n ] , a , b , c , d elements in K , i , j , k , l , n , o , q natural numbers, t | u t divides u , t / u division of power products (in case t | u ), C ( m ) the coefficient of monomial m , C ( p , t ) the coefficient at t in the polynomial p , M ( p , t ) = C ( t , p ) · t the monomial at t in p , S ( p ) = { t | C ( p , t ) (cid:54) = } the support of polynomial p .Moreover, we will use the following shortcut notation: P : = K [ x , . . . , x n ] , T : = [ x , . . . , x n ] . Definition 2 (Admissible ordering) . Let ≺ be a total ordering on T . Then, ≺ is admissible : ⇔ ∀ t (cid:54) = ( ≺ t ) , ∀ t , u , v ( t ≺ u ⇒ t · v ≺ u · v ) . Admissible orderings include the lexicographic ordering and reverse lexicographic ordering, totaldegree lexicographic and reverse lexicographic. See, for example, [3] for technical details.
Proposition 3 (Properties of admissible orderings) . Let ≺ be an admissible ordering on T . Then, ∀ t , u ( t | u ⇒ t (cid:22) u ) , ≺ is well founded . Admissible orderings allow decompositions of polynomials:
LPP ≺ ( p ) = max ≺ ( S ( p )) the leading power product of p , LC ≺ ( p ) = C ( p , LPP ≺ ( p )) the leading coefficient of p , LM ≺ ( p ) = LC ≺ ( p ) · LPP ≺ ( p ) the leading monomial of p , R ≺ ( p ) = p − LM ≺ ( p ) the remaining part of p .4 Gr¨obner Bases with Reduction Machines
Note that in case the admissible ordering is fixed, we will not write it as a subscript (e.g. will write
LPP ( p ) instead of LPP ≺ ( p ) ). Definition 4 (Reduction modulo polynomials) . g reduces to h modulo f using the power product t , g → f , t h : ⇔ t ∈ S ( g ) ∧ LPP ( f ) | t ∧ h = g − ( M ( g , t ) / LM ( f )) · f . g reduces to h modulo f , g → f h : ⇔ ∃ t ∈ S ( g )( g → f , t h ) . g reduces to h modulo the set F of polynomials . g → F h : ⇔ ∃ f ∈ F ( g → f h ) . Definition 5 (Normal forms) . g is in normal form modulo F , g F : ⇔ (cid:64) h ( g → F h ) . Let → F ∗ be the reflexive transitive closure of → F . h is a normal form of g modulo F iff g → F ∗ h ∧ h F . The reduction process can be iterated algorithmically.
Definition 6 (Normal form algorithm) . An algorithm S is called a normal form algorithm (or simplifier )iff g → F ∗ S ( F , g ) ∧ S ( F , g ) F . Some textbooks, e.g. [10], propose a maximal normal form algorithm, where the reduction is doneon the leading monomial. We will refer to it in this paper as the classic reduction algorithm . Lemma 7.
The classic reduction algorithm (Algorithm 8) is a normal form algorithm.
Algorithm 8 (Classic reduction) . h : = g while exists f ∈ F such that LPP ( f ) | LPP ( h ) dochoose f ∈ F such that h → f , LPP ( h ) h : = h − LC ( h ) · LPP ( h ) LPP ( f ) · f return h The correctness and termination of the algorithm can be found in [3].
Example 9.
Consider F = { f , f } , where f : = x + x − y , f : = x − . The polynomials f , f are orderedaccording to the degree lexicographic ordering. The leading power products are x , x , respectively, andthe leading coefficients are 1 and 1.Consider g : = x + x y + y . After one step of reduction, g reduces modulo F to h : = x y − x + xy + y . Namely, . S¸ urlea & A. Cr˘aciun h : = g − · x · f . The classic reduction of g modulo F yields the following sequence: g = x + x y + y (using f ) → F x y − x + xy + y (using f ) → F − x + y + y (using f ) → F y + x + y (using f ) → F y + y + Now, we consider what happens if, for the polynomial being reduced, we allow the choice of any mono-mial, not just the maximal one, as described in Algorithm 8. This is can be done, literature indicates themaximal choice is made for efficiency purposes (see, for example [5]). Normal forms can be computedusing other choices of monomials.
Definition 10 (Reduction process) . Let g = m + · · · + m n and let F = { f , . . . , f l } , such that a selectionstrategy for choosing elements from F to use for reduction is fixed. A reduction process of g modulo F represents all possible reductions of g modulo F to normal form. Definition 11 (Monomial reduction sequence) . A monomial reduction sequence is the sequence of mono-mials that were selected for reduction in the computation of a normal form within a reduction process.The systematic enumeration of all reductions yields a tree, similar to that in Figure 1. A monomialreduction sequence implicitly describes a branch of that tree. gg ... h . . . ... h i . . . g n ... h j . . . ... h k Figure 1: Tree representation of a reduction process.Now, for a reduction process, we consider the following questions:
Question 12.
Does this process terminate? Yes, see [3] for the termination proof.
Question 13.
Does this process lead to a normal form? Yes, also in [3].
Question 14.
Does a reduction process compute one normal form or more?
Question 15.
Can we identify the most efficient branch in the reduction process? Is this the standardreduction from Algorithm 8? Are there better choices? Is it easy to decide which choices would lead toshort(er) reductions?6
Gr¨obner Bases with Reduction Machines
Example 16.
Consider F = { f , f } , where f : = x + x − y , f : = x − . The polynomials f , f are or-dered according to the degree lexicographic ordering. The leading power products are x , x , respectively,and the leading coefficients are 1 and 1. Consider g : = x + x y + y . The (incomplete) reduction process is illustrated in Figure 2. Each node contains a polynomial.The bold face monomials are reducible and the edges correspond to the order in which monomials areselected for reduction, i.e. first edge corresponds to the reduction using the first monomial, and so on.Monomials that are grayed out are reducible, but for the sake of space we left out the correspondingbranches (branches that are not shown lead to the same result). The rest of monomials are irreducible. x +x y + y x y-x + xy + y -x + y + yy +x + yy + y + x y+xy + x + yy +x + yy + y + x y + x + y -xy + y + x + yy + y + x y + y + x -xy + y + y x + y -x +xy + y xy + y +x − yy +x + yy + y + xy + y − y + y + y + -x + y + yy +x + yy + y + To answer Question 14, we will first introduce a few notions, then prove that the answer is Yes.
Definition 17 (Monomial substitution) . Let m , m , . . . , m n be monomials, f a polynomial and F a set ofpolynomials, respectively, such that m → F f and f = m + . . . + m n . Then the sequence m , . . . , m n is a monomial substitution for m modulo F . Definition 18 (Reduction thread) . Let m be a monomial, F a set of polynomials (with a fixed selectionstrategy). A reduction thread for m modulo F replaces m with its monomial substitution modulo F . Theprocess is repeated for as long as there are reducible monomials. . S¸ urlea & A. Cr˘aciun Definition 19 (Reduction machine) . Let g = m + . . . + m n be a polynomial represented as the sum ofmonomials and F a set of polynomials. A reduction machine with inputs g and F is described in thefollowing way: • for each of the monomials m i , i = , . . . , n , construct its reduction thread, • for the resulting sequence of reduction threads, accumulate the sum of all the leaves (irreduciblemonomials) and return the result.Note that the reduction threads are independent of each other, by construction, so in principle theycan be executed in the same time. Definition 20 (Execution trace) . An execution trace of a reduction machine represents a configuration ofthe reduction machine, i.e. the reduction machine where the reduction threads have not been completed.This means that leaves of this execution trace are not necessarily irreducible. Example 21.
Let g = x + x y + xy + y and F = { x + x − y , x − } for which, as selection strategy,we choose polynomials according to the lexicographic ordering of their leading monomials. The classicreduction yields a sequence of the following form:4 x + x y + xy + y −−−−→ x y − x + xy + y −−−−→ − x + xy + y + y −−−−→ xy + y + x − y −−−−→ y + x + y , −−−−→ y + y + Theorem 22.
Let g = m + · · · + m n let F = { f , . . . , f l } be an ordered l-tuple of polynomials with a fixedselection strategy. Each branch of the reduction process of g with respect to F yields the same result.Proof. To prove the theorem, we will prove that the reduction process of g with respect to F and theassociated reduction machine are equivalent. This means that since the reduction machine yields a uniqueresult, so does the reduction process.We prove that any node p in the reduction process is computed by one execution trace in the corre-sponding reduction machine. Let s be the (partial) monomial reduction sequence that defines the pathfrom the root of the reduction process to p .8 Gr¨obner Bases with Reduction Machines x x y xy y [ − x , xy ] [ − xy , y ] [ y ][ x , − y ] [ y ] [ − y ][ ] Base case :In this case, p is the root of the reduction process, therefore, by definition, the polynomial is repre-sented in the reduction machine. Induction step :Assume that the property holds for monomial reduction sequence S , i.e. for polynomial p defined by S we have a unique corresponding execution trace in the reduction machine.Let m = c · t be a monomial chosen from p , where c is its coefficient, t its power product. We showthe property is true for the monomial reduction sequence S ∪ { m } .We write p = m + R ( p ) . Let ET be the execution trace of the reduction machine that corresponds topolynomial p . Since m is a monomial in p , it is collected from leaves of (partial) reduction threads from ET . Let these leaves be c · t , . . . , c n · t , n ≥
1, we know c = c + . . . c n .Let p (cid:48) be the polynomial such that p → f , t p (cid:48) by choosing the monomial m , using f ∈ F defined bythe fixed selection strategy.We show that there exists a unique execution trace ET (cid:48) that corresponds to p (cid:48) . By the definition ofreduction p (cid:48) = p − mLM ( f ) · R ( f ) . In other words, the monomial m is substituted by the polynomial s = − mLM ( f ) · R ( f ) , i.e. s = c · (cid:18) − tLM ( f ) · R ( f ) (cid:19) . Now, let ms , . . . , ms k be the monomials of the polynomial s . We build ET (cid:48) from ET in the followingway: we extend the reduction threads containing c · t , . . . , c n · t as leaves by adding the corresponding . S¸ urlea & A. Cr˘aciun t , obtaining new leaves c i · ms , . . . , c i · ms k , i = , . . . , n .Collecting the leaves of ET (cid:48) yields p (cid:48) .To summarize, we have shown that between making a step in the reduction process and extending anexecution trace using a monomial there is a one-to-one correspondence, which concludes the proof.Theorem 22 solves Question 14. This establishes confluence for reduction with a fixed reductorselection strategy , i.e. the choice of monomials that are to be reduced does not influence the final resultof the reduction. This is different from the notion of confluence that occurs in the context of Gr¨obnerbases in the following sense: for polynomial set F , → F is not confluent in general, i.e. different choicesof reductors from F may lead to different normal forms. However, if F is a Gr¨obner basis, then → F isconfluent.For Question 15, we initially considered trying to determine criteria that would make a computationshort, solving an optimization problem expressed in terms of degrees. However, the equivalence betweenreduction processes and reduction machines allows us to use the latter for doing reductions in parallel.We propose reduction machines as a candidate answer to Question 15. Here, we first present an algorithm that implements a reduction machine, then discuss some of its limi-tations and show how to improve it. We then briefly describe how we integrated these algorithms into aJava implementation of Gr¨obner bases. Finally, we discuss some experimental results.
The following algorithm is a straight-forward implementation of a reduction machine.
Algorithm 23 (Reduction machine) . M := monomials of gh := 0while M is not empty do m : = a monomial in M if m is reducible then S := substitution( m ) M : = M ∪ S else h : = h + mM : = M \ { m } return h Note, however, that this implementation has some inefficiencies. These are visible in Figure 3:the power product xy appears in 3 separate reduction threads, therefore we need to perform the samereduction 3 times. Furthermore, there could be situations where we reduce the same power productseveral times, only for this to be cancelled out after collecting the result.We can optimize the implementation by introducing a caching mechanism that will allow us to detectreductions that were already carried out and only update the coefficients. For this, we use the followingstructures:0 Gr¨obner Bases with Reduction Machines • A sequence of monomials with two types of markings. The marking unused represents a monomialwhich has not yet been processed. The marking og indicates a monomial of g . • A directed graph to represent reduction threads. A vertex in this graph consists of a power productand a set of multiples. These multiples contain coefficients of the power products from different re-duction threads, as well as coefficients inherited (by reduction) from parent vertices (if applicable).Edges in the graph show reduction steps.We now give the details. Algorithm 24 (Reduction machine with caching) . M := monomials of g ( unused , og ) G := empty graphwhile exists unused in M do m : = an unused monomial in M if m is og thenif existsVertex ( pp ( m ) , G ) thenupdateVertex ( pp ( m ) , c ( m ) , G )else createVertex ( pp ( m ) , c ( m ) , G )if m is reducible then S := substitution( pp ( m ) )expand ( pp ( m ) , S , G )update ( M , S )mark ( m , used)return collectRemainder ( G ) Subalgorithm expand ( pp , S , G ). source := getVertex ( pp , G )mark ( source , reducible )for each m in S doif containsVertex ( pp ( m ) , G ) then destination := getVertex( pp ( m ) , G )addMultiple ( c ( m ) , source , destination )else createVertex ( pp ( m ) , c ( m ) , source ) destination := getVertex( pp ( m ) , G )addEdge ( source , destination , G ) Subalgorithm update ( M , S ). for each m in S doif pp ( m ) does not exist in M then M := M ∪ { m } Subalgorithm collectRemainder ( G ). h := 0 I := irreducibleVertices( G )for each v in I do c = collectCoefficients( v , G )if c (cid:54) = then h := h + c · getPowerProduct( v )return h . S¸ urlea & A. Cr˘aciun Subalgorithm collectCoefficients ( v , G ). s := 0 C := getMultiples( v , G )for each m in C do s := s + getCoefficient( m )if hasParent ( m ) then s := s · collectCoefficients(getParent( m ))return s The collectRemainder(G) method starts from the vertices containing irreducible power products,i.e., leaf or isolated vertices, and propagates backwards the multiples across vertices containing reduciblepower products. An irreducible vertex inherits the coefficients of all reducible vertices connected to it.
Example 25.
Let F = { x + x − y , x − } and g = x + x y + xy + y be an ideal of polynomialsand a polynomial, respectively, ordered with respect to the lexicographic ordering. The oriented graphconstructed for this example is illustrated in Figure 4. x y x xy − · c ( x y ) · c ( x ) y · c ( x y ) x − · c ( x ) y · c ( xy ) · c ( x ) x − · c ( x ) · c ( x ) x u og , x y u og , u og y , xy u og , y u , x u , x u , u Figure 4: Reduction machine with caching, resulting graph and associated monomial sequence.
Our prototype Java library for Gr¨obner bases provides implementations for the following concepts, al-gorithms and problems: defining multivariate polynomials with coefficients over the field of rationalnumbers ( Q ), defining ideals, reducing a polynomial with respect to a basis, deciding whether a ba-sis is a Gr¨obner basis, computing a Gr¨obner basis given an ideal using Buchberger’s standard and im-proved algorithms, testing whether two given polynomials are congruent with respect to a basis, decidingwhether a polynomial belongs to the ideal generated by a Gr¨obner basis. The available orderings are de-clared in the public enumeration Ordering , as follows: lexicographic (LEX), reverse lexicographic2
Gr¨obner Bases with Reduction Machines (REVLEX), graded lexicographic (GRLEX), reverse graded lexicographic (GREVLEX). The versionsof Buchberger’s algorithm are declared in the public enumeration
GroebnerType , as follows: standardversion (CLASSIC) and improved version (IMPROVED).
We integrated sequential versions of the reduction machine in our implementation. We ran a collectionof 20 problems selected from literature. In order to account for any discrepancy between the executiontime values of two successive runs, we computed the execution time as the average time for 1000 runs.We compared the classic reduction and both versions of the reduction machine, integrated in theimproved version of Buchberger’s algorithm for computing reduced bases. We compare the results byproviding the number of the problem, without its structure. For the structure of the problem, we refer thereader to the collection listed in the Appendix. The resulting bases were computed with respect to thegraded lexicographic ordering (GRLEX). Results are shown in Figure 5. C indicates the use of classicreduction, RM the reduction machine and RMc the reduction machine with caching.1 2 3 4 6 7 8 9 11 12 13 14 16 17 18050100150200250 T i m e ( m s ) C RM RMc5 10 cyclic-3 cyclic-402004006008001 , T i m e ( m s ) Figure 5: Experimental results.From the experimental viewpoint, the method offers promising results. We can see that in somecases, reduction machines offer some improvements on the classic reduction, while in others they donot. However, the differences are not significant in most cases. Note that so far we only implemented . S¸ urlea & A. Cr˘aciun
In addition to the contributions mentioned in Subsection 1.2, such as Faug`ere’s F4, F5, there were otherattempts to use different forms of parallelism in order to improve computations of Gr¨obner bases, seefor example [15]. These efforts, however, focus on making several reductions in the same time. Reduc-tion machines bring parallelism inside the reduction. In this sense, our work is complementary to suchapproaches.Our implementation is an early prototype, therefore, at this moment we do not compare it to othersimilar applications such as Java Algebra System (JAS), see [15], or well established computer algebrasystems such as Mathematica, Maple, CoCoA, Magma, Macaulay2, Singular, Sage, etc.In fact, we tried out the different reduction methods with our prototype implementation in order tohave a level playing field for their comparison. Of course, we do not yet have the parallel version of thereduction machines in our implementation, but we expect these to perform much better. A practical wayforward is, perhaps, to implement reduction machines in the various existing systems.
Our main contribution in this paper is the concept of reduction machines and its implementation, togetherwith the proof that they are equivalent to corresponding reduction processes. In fact, we observed thebehaviour that led to the idea of reduction machines while trying to prove Theorem 22.We have a prototype implementation, in Java, of Gr¨obner bases which we used to test the impactof reduction machines on the performance of the Gr¨obner bases algorithm. The results are promising:taking into account that the sequential versions give relatively similar results to the classic reduction. Thenext obvious step is to implement parallel versions and test them extensively. We are also consideringintegrating reduction machines in existing open-source systems.Also, part of future research is an analysis of the complexity of reduction machines, both in thesequential and in the parallel case.4
Gr¨obner Bases with Reduction Machines
References [1] William W. Adams & Philippe Loustaunau (1994):
An Introduction to Gr¨obner Bases . 3, American Mathe-matical Society, doi:10.1090/gsm/003.[2] Joachim Apel & Ralf Hemmecke (2005):
Detecting unnecessary reductions in an involutive basis computa-tion . Journal of Symbolic Computation
Gr¨obner bases: a computational approach to commutativealgebra . Graduate texts in mathematics, Springer-Verlag, doi:10.1007/978-1-4612-0913-3.[4] B. Buchberger (1979):
A criterion for detecting unnecessary reductions in the construction of Gr¨obner-bases . In Edward W. Ng, editor:
Symbolic and Algebraic Computation , Springer Berlin Heidelberg, Berlin,Heidelberg, pp. 3–21, doi:10.1007/3-540-09519-5 52.[5] B. Buchberger (1985):
Multidimensional Systems Theory – Progress, Directions and Open Problems in Mul-tidimensional Systems , chapter Gr¨obner Bases: An Algorithmic Method in Polynomial Ideal Theory, pp.184–232. Reidel Publishing Company, doi:10.1007/978-94-017-0275-1 4.[6] B. Buchberger (1998):
Introduction to Gr¨obner Bases . London Mathematical Society Lectures Notes Series251, Cambridge University Press, doi:10.1017/CBO9780511565847.[7] Bruno Buchberger (2001):
Gr¨obner Bases: A Short Introduction for Systems Theorists . Research Institutefor Symbolic Computation
Bruno Buchberger’s PhD thesis 1965: An algorithm for finding the basis elementsof the residue class ring of a zero dimensional polynomial ideal . Journal of Symbolic Computation
Gr¨obner Basis . Scholarpedia
Ideals, Varieties, and Algorithms , 4th edition. Springer,doi:10.1007/978-3-319-16721-3.[11] Jean-Charles Faug`ere (1999):
A new efficient algorithm for computing Gr¨obner bases (F4) . Journal of Pureand Applied Algebra
A New Efficient Algorithm for Computing Gr¨obner Bases Without Reduction toZero (F5) . In:
Proceedings of the 2002 International Symposium on Symbolic and Algebraic Computation ,ISSAC ’02, ACM, New York, NY, USA, pp. 75–83, doi:10.1145/780506.780516.[13] Vladimir P. Gerdt & Yuri A. Blinkov (1998):
Involutive bases of polynomial ideals . Mathematics and Com-puters in Simulation ”One SugarCube, Please”; or Selection Strategies in the Buchberger Algorithm . In:
Proceedings of the 1991 Interna-tional Symposium on Symbolic and Algebraic Computation , ISSAC ’91, ACM, New York, NY, USA, pp.49–54, doi:10.1145/120694.120701.[15] Heinz Kredel (2010):
Parallel and distributed Gr¨obner bases computation in JAS . CoRR abs/1008.0011.[16] Ernst W Mayr & Albert R Meyer (1982):
The complexity of the word problems for commutative semigroupsand polynomial ideals . Advances in Mathematics
Solving Polynomial Equation Systems II: Macaulay’s Paradigmand Gr¨obner Technology . Encyclopedia of Mathematics and its Applications, Cambridge University Press,doi:10.1017/CBO9781107340954. . S¸ urlea & A. Cr˘aciun Appendix
Collection of problems I = < x + y + z − , x + y + z − , x + y + z − > [10]2. I = < x + y + , x y + xy + x > [1]3. I = < x y − , xy − x > [10]4. I = < x + y + z − , x + z − y , x − z > [10]5. I = < xz − y + z , x + y , xy + > I = < xy − y , y − x > [7]7. I = < y − x , z − x > I = < yx − x , y − x > [1]9. I = < y − x , z − x > [10]10. I = < x yz − xz , xy z − xyz , x y − z > [5]11. I = < x y + xy + y + x + x − , x y − xy − y + x − x − x + , x y + x y + x + x > [5]12. I = < xy + x + y , y − y − > [1]13. I = < x y + xy , y − y > I = < x y − y + x , xy − x > [1]15. I = < xy − yz − z , y − x z + xz , z − y x + x > [7]16. I = < x + y + xy , xy + , z + x y − z > I = < xy − xz + y , xy − z , x − yz > [10]18. I = < x y − z , x y − , x y − z > [10]19. I = < x + y + z , xy + yz + zx , xyz − > [cyclic-3]20. I = < w + x + y + z , wx + xy + yz + zw , wxy + xyz + yzw + zwx , wxyz − >>