Sage supports the following term orderings:
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='lex')
sage: x > y
True
sage: x > y^2
True
sage: x > 1
True
sage: x^1*y^2 > y^3*z^4
True
sage: x^3*y^2*z^4 < x^3*y^2*z^1
False
This term ordering is called ‘lp’ in Singular.
Let then or and
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='degrevlex')
sage: x > y
True
sage: x > y^2*z
False
sage: x > 1
True
sage: x^1*y^5*z^2 > x^4*y^1*z^3
True
sage: x^2*y*z^2 > x*y^3*z
False
This term ordering is called ‘dp’ in Singular.
Let then or and
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='deglex')
sage: x > y
True
sage: x > y^2*z
False
sage: x > 1
True
sage: x^1*y^2*z^3 > x^3*y^2*z^0
True
sage: x^2*y*z^2 > x*y^3*z
True
This term order is called ‘Dp’ in Singular.
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='invlex')
sage: x > y
False
sage: y > x^2
True
sage: x > 1
True
sage: x*y > z
False
This term ordering only makes sense in a non-commutative setting because if P is the ring and term ordering ‘invlex’ then it is equivalent to the ring with term ordering ‘lex’.
This ordering is called ‘rp’ in Singular.
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='neglex')
sage: x > y
False
sage: x > 1
False
sage: x^1*y^2 > y^3*z^4
False
sage: x^3*y^2*z^4 < x^3*y^2*z^1
True
sage: x*y > z
False
This term ordering is called ‘ls’ in Singular.
Let then or and
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='negdegrevlex')
sage: x > y
True
sage: x > x^2
True
sage: x > 1
False
sage: x^1*y^2 > y^3*z^4
True
sage: x^2*y*z^2 > x*y^3*z
False
This term ordering is called ‘ds’ in Singular.
Let then or and
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQ, 3, order='negdeglex')
sage: x > y
True
sage: x > x^2
True
sage: x > 1
False
sage: x^1*y^2 > y^3*z^4
True
sage: x^2*y*z^2 > x*y^3*z
True
This term ordering is called ‘Ds’ in Singular.
Of these, only ‘degrevlex’, ‘deglex’, ‘invlex’ and ‘lex’ are global orderings.
Additionally all these monomial orderings may be combined to product or block orderings, defined as:
Let and be two ordered sets of variables, a monomial ordering on and a monomial ordering on .
The product ordering (or block ordering) on is defined as: or .
These block orderings are constructed in Sage by giving a comma separated list of monomial orderings with the length of each block attached to them.
EXAMPLE:
As an example, consider constructing a block ordering where the first four variables are compared using the degree reverse lexicographical ordering while the last two variables in the second block are compared using negative lexicographical ordering.
sage: P.<a,b,c,d,e,f> = PolynomialRing(QQ, 6,order='degrevlex(4),neglex(2)')
sage: a > c^4
False
sage: a > e^4
True
sage: e > f^2
False
The same result can be achieved by:
sage: T1 = TermOrder('degrevlex',4)
sage: T2 = TermOrder('neglex',2)
sage: T = T1 + T2
sage: P.<a,b,c,d,e,f> = PolynomialRing(QQ, 6, order=T)
sage: a > c^4
False
sage: a > e^4
True
If any other unsupported term ordering is given the provided string is passed through as is to Singular, Macaulay2, and Magma. This ensures that it is for example possible to calculate a Groebner basis with respect to some term ordering Singular supports but Sage doesn’t. However a warning is issued to make the user aware of the situation and potential typos:
sage: T = TermOrder("royalorder")
verbose 0 (...: term_order.py, __init__) Term ordering 'royalorder' unknown.
AUTHORS:
Bases: sage.structure.sage_object.SageObject
A term order.
See sage.rings.polynomial.term_order for details on supported term orderings.
Compares two exponent tuples with respect to the degree lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='deglex')
sage: x > y^2 # indirect doctest
False
sage: x > 1
True
Compares two exponent tuples with respect to the negative degree lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='negdeglex')
sage: x > y^2 # indirect doctest
True
sage: x > 1
False
Compares two exponent tuples with respect to the block ordering as specified when constructing this element.
INPUT:
EXAMPLE:
sage: P.<a,b,c,d,e,f>=PolynomialRing(QQbar, 6, order='degrevlex(3),degrevlex(3)')
sage: a > c^4 # indirect doctest
False
sage: a > e^4
True
Compares two exponent tuples with respect to the degree reversed lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='degrevlex')
sage: x > y^2 # indirect doctest
False
sage: x > 1
True
Compares two exponent tuples with respect to the negative degree reverse lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='negdegrevlex')
sage: x > y^2 # indirect doctest
True
sage: x > 1
False
Compares two exponent tuples with respect to the lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='lex')
sage: x > y^2 # indirect doctest
True
sage: x > 1
True
Compares two exponent tuples with respect to the negative lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='neglex')
sage: x > y^2 # indirect doctest
False
sage: x > 1
False
Compares two exponent tuples with respect to the inversed lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y> = PolynomialRing(QQbar, 2, order='invlex')
sage: x > y^2 # indirect doctest
False
sage: x > 1
True
Returns the greater exponent tuple with respect to the total degree lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y,z> = PolynomialRing(QQbar, 3, order='deglex')
sage: f = x + y; f.lm() # indirect doctest
x
sage: f = x + y^2*z; f.lm()
y^2*z
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
Returns the greater exponent tuple with respect to the negative degree lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y,z> = PolynomialRing(QQbar, 3, order='negdeglex')
sage: f = x + y; f.lm() # indirect doctest
x
sage: f = x + x^2; f.lm()
x
sage: f = x^2*y*z^2 + x*y^3*z; f.lm()
x^2*y*z^2
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
Returns the greater exponent tuple with respect to the block ordering as specified when constructing this element.
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
INPUT:
EXAMPLE:
sage: P.<a,b,c,d,e,f>=PolynomialRing(QQbar, 6, order='degrevlex(3),degrevlex(3)')
sage: f = a + c^4; f.lm() # indirect doctest
c^4
sage: g = a + e^4; g.lm()
a
Returns the greater exponent tuple with respect to the total degree reversed lexicographical term order.
INPUT:
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQbar, 3, order='degrevlex')
sage: f = x + y; f.lm() # indirect doctest
x
sage: f = x + y^2*z; f.lm()
y^2*z
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
Returns the greater exponent tuple with respect to the negative degree reverse lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y,z> = PolynomialRing(QQbar, 3, order='negdegrevlex')
sage: f = x + y; f.lm() # indirect doctest
x
sage: f = x + x^2; f.lm()
x
sage: f = x^2*y*z^2 + x*y^3*z; f.lm()
x*y^3*z
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
Returns the greater exponent tuple with respect to the lexicographical term order.
INPUT:
EXAMPLES:
sage: P.<x,y,z> = PolynomialRing(QQbar, 3, order='lex')
sage: f = x + y^2; f.lm() # indirect doctest
x
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
Returns the greater exponent tuple with respect to the negative lexicographical term order.
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
INPUT:
EXAMPLE:
sage: P.<a,b,c,d,e,f>=PolynomialRing(QQbar, 6, order='degrevlex(3),degrevlex(3)')
sage: f = a + c^4; f.lm() # indirect doctest
c^4
sage: g = a + e^4; g.lm()
a
Returns the greater exponent tuple with respect to the inversed lexicographical term order.
INPUT:
EXAMPLE:
sage: P.<x,y,z> = PolynomialRing(QQbar, 3, order='invlex')
sage: f = x + y; f.lm() # indirect doctest
y
sage: f = y + x^2; f.lm()
y
This method is called by the lm/lc/lt methods of MPolynomial_polydict.
Return True if this term ordering is definitely global. Return False otherwise, which includes unknown term orderings.
EXAMPLE:
sage: T = TermOrder('lex')
sage: T.is_global()
True
sage: T = TermOrder('degrevlex', 3) + TermOrder('degrevlex', 3)
sage: T.is_global()
True
sage: T = TermOrder('degrevlex', 3) + TermOrder('negdegrevlex', 3)
sage: T.is_global()
False
Return True if this term ordering is definitely local. Return False otherwise, which includes unknown term orderings.
EXAMPLE:
sage: T = TermOrder('lex')
sage: T.is_local()
False
sage: T = TermOrder('negdeglex', 3) + TermOrder('negdegrevlex', 3)
sage: T.is_local()
True
sage: T = TermOrder('degrevlex', 3) + TermOrder('negdegrevlex', 3)
sage: T.is_local()
False
Return a Macaulay2 representation of self.
Used to convert polynomial rings to their Macaulay2 representation.
EXAMPLE:
sage: P = PolynomialRing(GF(127), 8,names='x',order='degrevlex(3),lex(5)')
sage: T = P.term_order()
sage: T.macaulay2_str()
'(GRevLex => 3,Lex => 5)'
sage: P._macaulay2_() # optional - macaulay2
ZZ/127 [x0, x1, x2, x3, x4, x5, x6, x7, MonomialOrder => {GRevLex => 3, Lex => 5}, MonomialSize => 16]
Return a MAGMA representation of self.
Used to convert polynomial rings to their MAGMA representation.
EXAMPLE:
sage: P = PolynomialRing(GF(127), 10,names='x',order='degrevlex')
sage: magma(P) # optional - magma
Polynomial ring of rank 10 over GF(127)
Graded Reverse Lexicographical Order
Variables: x0, x1, x2, x3, x4, x5, x6, x7, x8, x9
sage: T = P.term_order()
sage: T.magma_str()
'"grevlex"'
EXAMPLE:
sage: TermOrder('lex').name()
'lex'
Return a SINGULAR representation of self.
Used to convert polynomial rings to their SINGULAR representation.
EXAMPLE:
sage: P = PolynomialRing(GF(127),10,names='x',order='lex(3),deglex(5),lex(2)')
sage: T = P.term_order()
sage: T.singular_str()
'(lp(3),Dp(5),lp(2))'
sage: P._singular_()
// characteristic : 127
// number of vars : 10
// block 1 : ordering lp
// : names x0 x1 x2
// block 2 : ordering Dp
// : names x3 x4 x5 x6 x7
// block 3 : ordering lp
// : names x8 x9
// block 4 : ordering C