Define the polynomial ring $\mathrm{\ℚ}\left[\mathrm{x}\,\mathrm{y}\,\mathrm{z}\right]$ with the variable ordering $\mathrm{x}\>\mathrm{y}\>\mathrm{z}$. The field $\mathrm{\ℚ}$ of rational numbers is the default coefficient ring.

The internal representation of this polynomial ring can be accessed as follows.

Consider the following polynomial.

The main variable of $p$ as a polynomial of $R$ is given by:

The initial (or leading coefficient) of $p$:

The degree of $p$ in the main variable:

The rank of $p$, which is the main variable of $p$ raised to the main degree of $p$:

The tail of $p$.

The separant of $p$, which is the derivative of $p$ with regards to its main variable:

Change the ordering to $z\>y\>x$:

Consider the polynomial ring ${\mathrm{\ℤ}}_3\left[z\,y\,x\right]$ with the ordering $z\>y\>x$.

The command SubresultantChain in the ChainTools module is used to compute the subresultant chain of two polynomials. Let us illustrate this by an example.

Define a ring of polynomials.

Define two polynomials of R.

Compute their subresultant chain w.r.t the variable $y$

The result is of type $\mathrm{subresultant\_chain}$and encodes all the polynomials in the subresultant chain. To display the $i_{\mathrm{th}}$subresulant polynomial, one can call the command SubresultantOfIndex. For example, to know the subresultant of index $0\,$that is the resultant, one can do as follows

To display all the subresultant polynomials, one can call the command Display.

The encoding of the subresultants can be controlled by an optional argument. This encoding can be by values, over the monomial basis or via the Bezout Matrix.

When this optional argument is not specified, the encoding is chosen according to a heuristical algorithm.

Define a ring of polynomials.

Define a set of polynomials of $R$.

Ideally, one would like to decompose the solutions of sys into a list of points. This is what the command Triangularize does using symbolic expressions. In the output decomposition, some points are grouped because they share some properties. These groups are called regular chains.

A regular chain is a system of equations and inequations, satisfying special algebraic properties. First, the equation part consists of non-constant polynomials with pairwise different main variables; thus, the equation part has a triangular shape. Second, the inequation part consists of the initials of the polynomials defining the equations; moreover, the product of those initials is regular (that is, not a zero-divisor) modulo the saturated ideal of the equation part. This technical condition can be skipped by the non-expert reader, since in most practical examples the inequations are trivial and can be ignored. This is the case in our example where all initials are equal to 1, leading to trivial inequations.

The result is to be interpreted as follows: The system $\mathrm{sys}$ is equivalent to a union of four regular chains. The equations for the first such regular chain are $x-1\=y\=z\=0$, the equations for the second regular chain are $x\=y-1\=z\=0$, etc. None of the four regular chains have any inequations. The first three regular chains have exactly one solution, and the last one has two solutions.

Note that you can also specify inequations of the form $p\ne 0$. For example, you can specify that $x-z$ must not vanish.

In the previous examples, the polynomial systems have finitely many solutions. To illustrate how the Triangularize command handles systems with infinitely many solutions, consider the following parametric linear system with unknowns $x\,y$ and parameters $a\,b\,c\,d\,g\,h$.

By default, the Triangularize command computes the generic solutions of the input system. For this parametric linear system, this implies its determinant is assumed to be nonzero.

Thus, the resulting regular chain consists of the two equations $c x\+d y-h\=\left(a d-b c\right)y\+c g-a h\=0$ and the two inequations $c\ne 0\ne a d-b c$, the first of which reflects the choice of $c$ as a pivot.

The other available Maple commands for solving such a system do a similar job.

The Triangularize command can do more if the option "output=lazard" is used. In this case, all the solutions of the input are computed, generic or not. This implies that the case where the determinant vanishes is also considered and solved.  For each regular chain below, its equations and inequations are printed.

One may also want to "push" some parameters into the field of coefficients, that is, to solve over a field of rational functions. Consider a new polynomial ring over the field $\mathrm{\ℚ}\left(g\,h\right)$ of rational functions in $g$ and $h$.

Finally, we solve over ${\mathrm{\mathbb{Z}}}_3\left(g\,h\right)$, that is, over the field of rational functions in $g$ and $h$ modulo 3.

The main subroutine of the Triangularize command is the RegularGcd command, which computes polynomial gcds modulo regular chains. This routine is illustrated hereafter together with basic commands on regular chains from the ChainTools submodule.

Here's the empty regular chain and its internal representation.

You can construct a new regular chain by adding a (suitable) polynomial $p$ to an existing regular chain $T$. This operation may return a list of regular chains. Indeed, checking that the initial of $p$ is regular with regards to (the saturated ideal of) $T$ may split $T$.

On the example below, this does not happen; the regular chain $T$ is empty.

The internal representation of the new regular chain $\mathrm{rc}$ is as follows. For each polynomial in the regular chain, the data structure stores its main variable, its main degree, and its initial. These quantities are needed quite frequently and are therefore cached to avoid recomputing them each time they are needed.

The internal representation also shows a property about the regular chain: isPrime. This means that its saturated ideal is a prime ideal. The knowledge of such property helps to speed up computations.

Now compute the greatest common divisor of two polynomials $p_1$and $p_2$modulo $\mathrm{rc}$. The example is designed such that $y+1$ is a gcd.

In general, the output of a gcd computation modulo a regular chain is a list of "cases".

In the above example, no case splits can happen since $\mathrm{rc}$ defines a field. However, note that the output, below, is not exactly the one expected.

However, the extraneous factor $2 x$ is a unit modulo $\mathrm{rc}$. Thus, the expected and the computed gcds are in fact associate, and therefore the result is correct.

Consider an example where a split is necessary during a gcd computation. To create such an example, you need to make sure that the input equations do not factor, because otherwise the Construct command will already split the system. The example below has three variables; the two variables $x$ and $y$ are used for building a regular chain with two polynomials $\mathrm{mx}$ and $\mathrm{my}$.

The first polynomial is irreducible over <.

Thus, constructing a regular chain from it produces a single output. Make a copy of it for later use.

The Construct command has detected that (the saturated ideal of) $\mathrm{rc}$ is a prime ideal.

The second polynomial is not irreducible in $\mathrm{\&rationals;}\left[x\right]\left[y\right]$. The Construct command would easily discover this fact and would split it when constructing a regular chain involving $\mathrm{rc}$.

By reducing $\mathrm{my}$ modulo $\mathrm{rc}$, the reduced polynomial becomes irreducible in $\mathrm{\mathbb{Q}}\left[x\right]\left[y\right]$.

Extend $\mathrm{rc}$ by $\mathrm{my}$.

The Construct command uses inexpensive criteria to detect whether the associated saturated ideal is prime or not. These criteria fail here. So the constructed regular chain $\mathrm{rc}$ has no particular properties.

Compute the gcd of $p_1$ and $p_2$, defined below, modulo $\mathrm{rc}$.

The example is constructed in such a way that splitting is needed: modulo the first factor of $\mathrm{my}$, namely $y-x$, the gcd is $z\&plus;1$, while it is constant modulo the second factor, $y\&plus;x-1$. Correspondingly, there are two branches.

Check the first case.

Note that ${\mathrm{rc}}_1$ is not normalized. The SparsePseudoRemainder computation shows that it corresponds to the "modulo $y-x$" branch.

This is the desired result, up to a multiplicative factor $-4x+9$ which is a unit modulo ${\mathrm{rc}}_1$.

Check the second case. Again, the regular chain ${\mathrm{rc}}_2$ is not normalized, and the SparsePseudoRemainder computation shows that it corresponds to the "modulo $y+x-1$" branch.

Check that $g_2$ is a unit modulo ${\mathrm{rc}}_2$. First, reduce it modulo ${\mathrm{rc}}_2$. Then ask if the result is invertible modulo ${\mathrm{rc}}_2$. The answer proves it is.

The central command of the RegularChains library is the Triangularize  command. The algorithm behind this command solves systems of equations incrementally. To do this, we rely on an important operation Intersect, which computes the common part of a hypersurface and the quasi-component of a regular chain. See the help page of Intersect for a more formal description of it. Let us now illustrate how to use it to solve a polynomial system incrementally.

Define a ring of polynomials.

Define a set of equations.

Define the empty regular chain.

Solve the first equation.

Solve the first and second equations.

Solve the three equations together.

Consider the generic equation of degree two.

Compute a triangular decomposition of the 4-variable hypersurface it defines.