]> Top Introduction to grobner grobner is a package for working with Groebner bases in Maxima. A tutorial on Groebner Bases can be found at http://www.geocities.com/CapeCanaveral/Hall/3131/ To use the following functions you must load the grobner.lisp package. load(grobner); A demo can be started by demo("grobner.demo"); or batch("grobner.demo") Some of the calculation in the demo will take a lot of time therefore the output grobner-demo.output of the demo can be found in the same directory as the demo file. Notes on the grobner packageThe package was written by Marek Rychlik http://alamos.math.arizona.edu and is released 2002-05-24 under the terms of the General Public License(GPL) (see file grobner.lisp. This documentation was extracted from the files README, grobner.lisp, grobner.demo, grobner-demo.output by Günter Nowak. Suggestions for improvement of the documentation can be discussed at the maxima-mailing-list . The code is a little bit out of date now. Modern implementation use the fast F4 algorithm described in A new efficient algorithm for computing Gröbner bases (F4) Jean-Charles Faugère LIP6/CNRS Université Paris VI January 20, 1999 Implementations of admissible monomial orders in grobner lexpure lexicographic,default order for monomial comparisons grlextotal degree order, ties broken by lexicographic grevlextotal degree, ties broken by reverse lexicographic invlexinverse lexicographic order Definitions for grobner Global switches for grobner poly_monomial_order — Option variable: poly_monomial_order Default value: lexThis global switch controls which monomial order is used in polynomial and Groebner Bases calculations. If not set, lex will be used. poly_coefficient_ring — Option variable: poly_coefficient_ring Default value: expression_ringThis switch indicates the coefficient ring of the polynomials thatwill be used in grobner calculations. If not set, maxima's generalexpression ring will be used. This variable may be set toring_of_integers if desired. poly_primary_elimination_order — Option variable: poly_primary_elimination_order Default value: falseName of the default order for eliminated variables inelimination-based functions. If not set, lex will be used. poly_secondary_elimination_order — Option variable: poly_secondary_elimination_order Default value: falseName of the default order for kept variables in elimination-based functions. If not set, lex will be used. poly_elimination_order — Option variable: poly_elimination_order Default value: falseName of the default elimination order used in eliminationcalculations. If set, it overrides the settings in variablespoly_primary_elimination_order and poly_secondary_elimination_order.The user must ensure that this is a true elimination order validfor the number of eliminated variables. poly_return_term_list — Option variable: poly_return_term_list Default value: falseIf set to true, all functions in this package will return eachpolynomial as a list of terms in the current monomial order ratherthan a maxima general expression. poly_grobner_debug — Option variable: poly_grobner_debug Default value: falseIf set to true, produce debugging and tracing output. poly_grobner_algorithm — Option variable: poly_grobner_algorithm Default value: buchbergerPossible values: buchberger parallel_buchberger gebauer_moeller The name of the algorithm used to find the Groebner Bases. poly_top_reduction_only — Option variable: poly_top_reduction_only Default value: falseIf not false, use top reduction only whenever possible. Topreduction means that division algorithm stops after the firstreduction. Simple operators in grobnerpoly_add, poly_subtract, poly_multiply and poly_expt are the arithmetical operations on polynomials. These are performed using the internal representation, but the results are converted back to the maxima general form. poly_add — Function: poly_add ( poly1 , poly2 , varlist ) Adds two polynomials poly1 and poly2. (%i1) poly_add(z+x^2*y,x-z,[x,y,z]); 2 (%o1) x y + x poly_subtract — Function: poly_subtract ( poly1 , poly2 , varlist ) Subtracts a polynomial poly2 from poly1. (%i1) poly_subtract(z+x^2*y,x-z,[x,y,z]); 2 (%o1) 2 z + x y - x poly_multiply — Function: poly_multiply ( poly1 , poly2 , varlist ) Returns the product of polynomials poly1 and poly2. (%i2) poly_multiply(z+x^2*y,x-z,[x,y,z])-(z+x^2*y)*(x-z),expand; (%o1) 0 poly_s_polynomial — Function: poly_s_polynomial ( poly1 , poly2 , varlist ) Returns the syzygy polynomial (S-polynomial) of two polynomials poly1 and poly2. poly_primitive_part — Function: poly_primitive_part ( poly1 , varlist ) Returns the polynomial poly divided by the GCD of its coefficients. (%i1) poly_primitive_part(35*y+21*x,[x,y]); (%o1) 5 y + 3 x poly_normalize — Function: poly_normalize ( poly , varlist ) Returns the polynomial poly divided by the leading coefficient.It assumes that the division is possible, which may not always be thecase in rings which are not fields. Other functions in grobner poly_expand — Function: poly_expand ( poly , varlist ) This function parses polynomials to internal form and back. Itis equivalent to expand(poly) if poly parses correctly toa polynomial. If the representation is not compatible with apolynomial in variables varlist, the result is an error.It can be used to test whether an expression correctly parses to theinternal representation. The following examples illustrate thatindexed and transcendental function variables are allowed. (%i1) poly_expand((x-y)*(y+x),[x,y]); 2 2 (%o1) x - y (%i2) poly_expand((y+x)^2,[x,y]); 2 2 (%o2) y + 2 x y + x (%i3) poly_expand((y+x)^5,[x,y]); 5 4 2 3 3 2 4 5 (%o3) y + 5 x y + 10 x y + 10 x y + 5 x y + x (%i4) poly_expand(-1-x*exp(y)+x^2/sqrt(y),[x]); 2 y x (%o4) - x %e + ------- - 1 sqrt(y) (%i5) poly_expand(-1-sin(x)^2+sin(x),[sin(x)]); 2 (%o5) - sin (x) + sin(x) - 1 poly_expt — Function: poly_expt ( poly , number , varlist ) exponentitates poly by a positive integer number. If number is not a positive integer number an error will be raised. (%i1) poly_expt(x-y,3,[x,y])-(x-y)^3,expand; (%o1) 0 poly_content — Function: poly_content ( poly . varlist ) poly_content extracts the GCD of its coefficients (%i1) poly_content(35*y+21*x,[x,y]); (%o1) 7 poly_pseudo_divide — Function: poly_pseudo_divide ( poly , polylist , varlist ) Pseudo-divide a polynomial poly by the list of n polynomials polylist. Returnmultiple values. The first value is a list of quotients a. Thesecond value is the remainder r. The third argument is a scalarcoefficient c, such that c*poly can be divided by polylist within the ringof coefficients, which is not necessarily a field. Finally, thefourth value is an integer count of the number of reductionsperformed. The resulting objects satisfy the equation:c*poly=sum(a[i]*polylist[i],i=1...n)+r. poly_exact_divide — Function: poly_exact_divide ( poly1 , poly2 , varlist ) Divide a polynomial poly1 by another polynomial poly2. Assumes that exactdivision with no remainder is possible. Returns the quotient. poly_normal_form — Function: poly_normal_form ( poly , polylist , varlist ) poly_normal_form finds the normal form of a polynomial poly with respectto a set of polynomials polylist. poly_buchberger_criterion — Function: poly_buchberger_criterion ( polylist , varlist ) Returns true if polylist is a Groebner basis with respect to the current termorder, by using the Buchbergercriterion: for every two polynomials h1 and h2 in polylist theS-polynomial S(h1,h2) reduces to 0 modulo polylist. poly_buchberger — Function: poly_buchberger ( polylist_fl varlist ) poly_buchberger performs the Buchberger algorithm on a list ofpolynomials and returns the resulting Groebner basis. Standard postprocessing of Groebner Bases The k-th elimination Ideal I_k of an Ideal I over K[ x[1],...,x[n] ] is the ideal intersect(I, K[ x[k+1],...,x[n] ]). The colon ideal I:J is the ideal {h|for all w in J: w*h in I}. The ideal I:p^inf is the ideal {h| there is a n in N: p^n*h in I}. The ideal I:J^inf is the ideal {h| there is a n in N and a p in J: p^n*h in I}. The radical ideal sqrt(I) is the ideal {h| there is a n in N : h^n in I }. poly_reduction — Function: poly_reduction ( polylist , varlist ) poly_reduction reduces a list of polynomials polylist, so thateach polynomial is fully reduced with respect to the other polynomials. poly_minimization — Function: poly_minimization ( polylist , varlist ) Returns a sublist of the polynomial list polylist spanning the samemonomial ideal as polylist but minimal, i.e. no leading monomialof a polynomial in the sublist divides the leading monomialof another polynomial. poly_normalize_list — Function: poly_normalize_list ( polylist , varlist ) poly_normalize_list applies poly_normalize to each polynomial in the list.That means it divides every polynomial in a list polylist by its leading coefficient. poly_grobner — Function: poly_grobner ( polylist , varlist ) Returns a Groebner basis of the ideal span by the polynomials polylist. Affected by the global flags. poly_reduced_grobner — Function: poly_reduced_grobner ( polylist , varlist ) Returns a reduced Groebner basis of the ideal span by the polynomials polylist. Affected by the global flags. poly_depends_p — Function: poly_depends_p ( poly , var , varlist ) poly_depends tests whether a polynomial depends on a variable var. poly_elimination_ideal — Function: poly_elimination_ideal ( polylist , number , varlist ) poly_elimination_ideal returns the grobner basis of the number-th elimination ideal of anideal specified as a list of generating polynomials (not necessarily Groebner basis poly_colon_ideal — Function: poly_colon_ideal ( polylist1 , polylist2 , varlist ) Returns the reduced Groebner basis of the colon idealI(polylist1):I(polylist2)where polylist1 and polylist2 are two lists of polynomials. poly_ideal_intersection — Function: poly_ideal_intersection ( polylist1 , polylist2 , varlist ) poly_ideal_intersection returns the intersection of two ideals. poly_lcm — Function: poly_lcm ( poly1 , poly2 , varlist ) Returns the lowest common multiple of poly1 and poly2. poly_gcd — Function: poly_gcd ( poly1 , poly2 , varlist ) Returns the greatest common divisor of poly1 and poly2. poly_grobner_equal — Function: poly_grobner_equal ( polylist1 , polylist2 , varlist ) poly_grobner_equal tests whether two Groebner Bases generate the same ideal.Returns true if two lists of polynomials polylist1 and polylist2, assumed to be Groebner Bases,generate the same ideal, and false otherwise.This is equivalent to checking that every polynomial of the first basis reduces to 0modulo the second basis and vice versa. Note that in the example below thefirst list is not a Groebner basis, and thus the result is false. (%i1) poly_grobner_equal([y+x,x-y],[x,y],[x,y]); (%o1) false poly_grobner_subsetp — Function: poly_grobner_subsetp ( polylist1 , polylist2 , varlist ) poly_grobner_subsetp tests whether an ideal generated by polylist1is contained in the ideal generated by polylist2. For this test to always succeed,polylist2 must be a Groebner basis. poly_grobner_member — Function: poly_grobner_member ( poly , polylist , varlist ) Returns true if a polynomial poly belongs to the ideal generated by thepolynomial list polylist, which is assumed to be a Groebner basis. Returns false otherwise.poly_grobner_member tests whether a polynomial belongs to an ideal generated by a list of polynomials,which is assumed to be a Groebner basis. Equivalent to normal_form being 0. poly_ideal_saturation1 — Function: poly_ideal_saturation1 ( polylist , poly , varlist ) Returns the reduced Groebner basis of the saturation of the idealI(polylist):poly^infGeometrically, over an algebraically closed field, this is the setof polynomials in the ideal generated by polylist which do not identicallyvanish on the variety of poly. poly_ideal_saturation — Function: poly_ideal_saturation ( polylist1 , polylist2 , varlist ) Returns the reduced Groebner basis of the saturation of the idealI(polylist1):I(polylist2)^infGeometrically, over an algebraically closed field, this is the set of polynomials inthe ideal generated by polylist1 which do not identically vanish on thevariety of polylist2. poly_ideal_polysaturation1 — Function: poly_ideal_polysaturation1 ( polylist1 , polylist2 , varlist ) polylist2 ist a list of n polynomials [poly1,...,polyn].Returns the reduced Groebner basis of the idealI(polylist):poly1^inf:...:polyn^infobtained by asequence of successive saturations in the polynomialsof the polynomial list polylist2 of the ideal generated by thepolynomial list polylist1. poly_ideal_polysaturation — Function: poly_ideal_polysaturation ( polylist , polylistlist , varlist ) polylistlist is a list of n list of polynomials [polylist1,...,polylistn].Returns the reduced Groebner basis of the saturation of the idealI(polylist):I(polylist_1)^inf:...:I(polylist_n)^inf poly_saturation_extension — Function: poly_saturation_extension ( poly , polylist , varlist1 , varlist2 ) poly_saturation_extension implements the famous Rabinowitz trick. poly_polysaturation_extension — Function: poly_polysaturation_extension ( poly , polylist , varlist1 , varlist2 )