Documentation

# `Dom`::`MonomOrdering`

Monomial orderings

MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

## Syntax

```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(WeightedDegLex(`w1, …,wn`))
Dom::MonomOrdering(WeightedDegRevLex(`w1, …,wn`))
Dom::MonomOrdering(WeightedRevLex(`w1, …,wn`))
Dom::MonomOrdering(Block(`o1, …`))
Dom::MonomOrdering(Matrix(`params`))
```

## Description

`Dom::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.

In MuPAD®, a monomial ordering is implemented as a function that, when applied to two lists of nonnegative integers, returns `-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.

Monomial orderings are used in algebraic geometry for comparing terms and in a polynomial ring. Since `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`.

Elements of `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))` 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.

Weight vectors with negative entries and order matrices do not define well-orderings in general. You may enter such orderings, but it may cause trouble, e.g., to use them with the groebner package.

## Superdomain

`Dom::BaseDomain`

## Categories

`Cat::BaseCategory`

## Examples

### Example 1

We define `ORD` by prescribing that lists [a, b, c] are ordered according to their weighted degrees 5 a + 2 b + π 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))`
` `

With respect to `ORD`, `[1, 6, 1]` is smaller than `[2, 1, 3]`:

`ORD([1,6,1], [2,1,3])`
` `

## Parameters

 `n` Positive integer `w1, …` Numerical expressions `o1, …` Valid arguments to `Dom::MonomOrdering` `params` A sequence valid as the sequence of arguments to `Dom::Matrix``()`.

## Methods

expand all

#### Mathematical Methods

`func_call(o, l1, l2)`

The lengths of `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.

#### Access Methods

`ordertype(o)`

If `o` equals `Dom::MonomOrdering(someIdentifier(params))`, then converting `someIdentifier` into a string gives the order type of `o`.

`orderlength(o)`

`nops(o)`

`block(o, i)`

`blocktype(o, i)`

`blocklength(o, i)`

#### Conversion Methods

`expr(o)`