Dom::MonomOrdering --
monomial orderings
IntroductionDom::MonomOrdering represents the set of all possible
monomial orderings. A monomial ordering is a well-ordering of the set
of all k-tuples of nonnegative integers for some
k.
DomainDom::MonomOrdering()
Details-1, 0, or 1 if the first list is
respectively smaller than, equal to, or greater than the second list.
Each ordering can only compare lists of one fixed length, called its
its order length. Since the lists under consideration will be
exponent vectors in most cases, their length is also referred to as the
number of indeterminates.Dom::MonomOrdering works on the exponent vectors
[α1, ..., αn] and
[β1, ..., βn], degreevec must be applied to
the terms to be compared before applying
Dom::MonomOrdering.Dom::MonomOrdering can be used as
arguments for lcoeff,
lmonomial, lterm, and tcoeff as well as for the functions
of the groebner
package in order to specify the monomial ordering to be
considered.
IntroductionMonomial orderings are created by calling
Dom::MonomOrdering(someIdentifier(parameters)),
where someIdentifier is one of a certain set of predefined
identifiers, as stated below. Converting someIdentifier
into a string gives the order type of the monomial
ordering.
Creating
ElementsDom::MonomOrdering(Lex(n))
Dom::MonomOrdering(RevLex(n))
Dom::MonomOrdering(DegLex(n))
Dom::MonomOrdering(DegRevLex(n))
Dom::MonomOrdering(DegInvLex(n))
Dom::MonomOrdering(WeightedLex(w1,
...,wn))
Dom::MonomOrdering(WeightedRevLex(w1,
...,wn))
Dom::MonomOrdering(WeightedDegLex(w1,
..,wn))
Dom::MonomOrdering(WeightedDegRevLex(w1,
..,wn))
Dom::MonomOrdering(Block(o1...))
Dom::MonomOrdering(Matrix(params))
Parametersn |
- | positive integer |
w1... |
- | numerical expressions |
o1,.. |
- | valid arguments to
Dom::MonomOrdering |
params |
- | a sequence valid as the sequence of arguments to
Dom::Matrix(). |
Cat::BaseCategory
DetailsDom::MonomOrdering(Lex(n)) creates the
lexicographical order on n indeterminates.Dom::MonomOrdering(RevLex(n)) creates the
reverse lexicographical order on n indeterminates, i.e.,
Dom::MonomOrdering(RevLex(n))([a1,...,an])= Dom::MonomOrdering(Lex(n))([an,...,a1]).Dom::MonomOrdering(DegLex(n)) creates the
degree order on n indeterminates with the lexicographical
order used for tie-break.Dom::MonomOrdering(DegRevLex(n)) creates
the degree order on n indeterminates with the reverse
lexicographical order used for tie-break .Dom::MonomOrdering(DegInvLex(n)) creates
the degree order on n indeterminates, with the tie break
being the opposite to the lexicographical order.Dom::MonomOrdering(Weighted...(w1,...,wn))
returns a weighted degree order with weights w1
through wn. The word following the word
Weighted specifies the tie-break used. Note that
MuPAD uses the ordinary degree order as the first
tie-break.Dom::MonomOrdering(Matrix(params))
creates a matrix order, with the order matrix defined by Dom::Matrix()(params).Dom::MonomOrdering(Block(o1, ..., on))
or, equivalently, Dom::MonomOrdering([o1, ...,
on]), creates a block order such that
Dom::MonomOrdering(o1) is used on the first
indeterminates, then Dom::MonomOrdering(o2)
is used as a tie-break on the following indeterminates etc.
Block orders may be nested, i.e., the blocks may be block orders, too.
groebner package.func_call(dom o, list
l1, list l2)o(l1, l2). It
returns -1 if l1 < l2, 1 if
l1>l2, and 0 if l1=l2.l1 and l2 must not exceed
the order length of o. If l1 or
l2 is too short, the necessary number of zeroes is
appended.ordertype(dom o)o.o equals
Dom::MonomOrdering(someIdentifier(params)),
then converting someIdentifier into a string gives the
order type of o.orderlength(dom o)o; this is the largest
integer k for which o works on lists of length
k.nops(dom o)Dom::MonomOrdering(Block(o1,...,on)) is said
to have n blocks. An order of any other type is said to have
one block.block(dom o, positive
integer i)o, or
FAIL if the order o does not have that many
blocks.blocktype(dom o, positive
integer i)o.blocklength(dom o, positive integer i)o.expr(dom o)someIdentifier(parameters) such that applying
Dom::MonomOrdering to it would give back
o.
Example
1We define ORD by prescribing that lists
[a,b,c] are ordered according to their weighted degrees
5a + 2b + πc. For lists with equal weighted degree, the
non-weighted degree a+b+c is used as a tie-break. Finally,
the lexicographical order decides (in fact, this last step is not
necessary because π is irrational).
>> ORD:=Dom::MonomOrdering(WeightedDegLex(5, 2, PI))
WeightedDegLex(5, 2, PI)
With respect to ORD, [1, 6, 1]
is smaller than [2, 1, 3]:
>> ORD([1,6,1], [2,1,3])
-1
Super-Domain