Dom::MonomOrdering
--
monomial orderingsDom::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.
Dom::MonomOrdering()
-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.Monomial 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.
Dom::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))
n |
- | 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
Dom::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
.We 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