9.40 LazardSetSolvingPackage
The LazardSetSolvingPackage package constructor solves
polynomial systems by means of Lazard triangular sets. However one
condition is relaxed: Regular triangular sets whose saturated ideals
have positive dimension are not necessarily normalized.
The decompositions are computed in two steps. First the algorithm of
Moreno Maza (implemented in the RegularTriangularSet domain
constructor) is called. Then the resulting decompositions are
converted into lists of square-free regular triangular sets and the
redundant components are removed. Moreover, zero-dimensional regular
triangular sets are normalized.
Note that the way of understanding triangular decompositions
is detailed in the example of the RegularTriangularSet
constructor.
The LazardSetSolvingPackage constructor takes six arguments.
The first one, R, is the coefficient ring of the polynomials; it
must belong to the category GcdDomain. The second one, E,
is the exponent monoid of the polynomials; it must belong to the
category OrderedAbelianMonoidSup. the third one, V, is
the ordered set of variables; it must belong to the category OrderedSet. The fourth one is the polynomial ring; it must belong to
the category RecursivePolynomialCategory(R,E,V). The fifth one
is a domain of the category RegularTriangularSetCategory(R,E,V,P)
and the last one is a domain of
the category SquareFreeRegularTriangularSetCategory(R,E,V,P).
The abbreviation for LazardSetSolvingPackage is LAZM3PK.
N.B. For the purpose of solving zero-dimensional algebraic systems,
see also LexTriangularPackage and ZeroDimensionalSolvePackage.
These packages are easier to call than LAZM3PK.
Moreover, the ZeroDimensionalSolvePackage
package provides operations
to compute either the complex roots or the real roots.
We illustrate now the use of the LazardSetSolvingPackage package
constructor with two examples (Butcher and Vermeer).
Define the coefficient ring.
Type: Domain
Define the list of variables,
ls : List Symbol := [b1,x,y,z,t,v,u,w]
Type: List Symbol
and make it an ordered set:
|
|
Type: Domain
then define the exponent monoid.
|
|
Type: Domain
Define the polynomial ring.
|
|
Type: Domain
Let the variables be polynomial.
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Now call the RegularTriangularSet domain constructor.
|
|
Type: Domain
Define a polynomial system (the Butcher example).
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p1 := 2*z*u + 2*y*v + 2*t*w - 2*w**2 - w - 1
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p2 := 3*z*u**2 + 3*y*v**2 - 3*t*w**2 + 3*w**3 + 3*w**2 - t + 4*w
|
|
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p3 := 6*x*z*v - 6*t*w**2 + 6*w**3 - 3*t*w + 6*w**2 - t + 4*w
|
|
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p4 := 4*z*u**3+ 4*y*v**3+ 4*t*w**3- 4*w**4 - 6*w**3+ 4*t*w- 10*w**2- w- 1
|
|
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p5 := 8*x*z*u*v +8*t*w**3 -8*w**4 +4*t*w**2 -12*w**3 +4*t*w -14*w**2 -3*w -1
|
|
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p6 := 12*x*z*v**2+12*t*w**3 -12*w**4 +12*t*w**2 -18*w**3 +8*t*w -14*w**2 -w -1
|
|
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
p7 := -24*t*w**3 + 24*w**4 - 24*t*w**2 + 36*w**3 - 8*t*w + 26*w**2 + 7*w + 1
|
|
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
lp := [p0, p1, p2, p3, p4, p5, p6, p7]
|
|
Type: List NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
First of all, let us solve this system in the sense of Lazard by means
of the REGSET constructor:
lts := zeroSetSplit(lp,false)$T
|
|
Type: List
RegularTriangularSet(Integer,
IndexedExponents OrderedVariableList [b1,x,y,z,t,v,u,w],
OrderedVariableList [b1,x,y,z,t,v,u,w],
NewSparseMultivariatePolynomial(
Integer,OrderedVariableList [b1,x,y,z,t,v,u,w]))
We can get the dimensions of each component
of a decomposition as follows.
[coHeight(ts) for ts in lts]
Type: List NonNegativeInteger
The first five sets have a simple shape. However, the last one, which
has dimension zero, can be simplified by using Lazard triangular sets.
Thus we call the SquareFreeRegularTriangularSet domain constructor,
|
|
Type: Domain
and set the LAZM3PK package constructor to our situation.
pack := LAZM3PK(R,E,V,P,T,ST)
|
|
Type: Domain
We are ready to solve the system by means of Lazard triangular sets:
zeroSetSplit(lp,false)$pack
|
|
Type: List
SquareFreeRegularTriangularSet(Integer,
IndexedExponents OrderedVariableList [b1,x,y,z,t,v,u,w],
OrderedVariableList [b1,x,y,z,t,v,u,w],
NewSparseMultivariatePolynomial(Integer,
OrderedVariableList [b1,x,y,z,t,v,u,w]))
We see the sixth triangular set is nicer now: each one of its
polynomials has a constant initial.
We follow with the Vermeer example. The ordering is the usual one
for this system.
Define the polynomial system.
f0 := (w - v) ** 2 + (u - t) ** 2 - 1
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
f2 := 2 * t * (w - v) + 3 * v ** 2 * (u - t)
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
f3 := (3 * z * v ** 2 - 1) * (2 * z * t - 1)
Type: NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
|
|
Type: List NewSparseMultivariatePolynomial(Integer,OrderedVariableList [b1,x,y,z,t,v,u,w])
First of all, let us solve this system in the sense of Kalkbrener by
means of the REGSET constructor:
|
|
Type: List
RegularTriangularSet(Integer,
IndexedExponents OrderedVariableList [b1,x,y,z,t,v,u,w],
OrderedVariableList [b1,x,y,z,t,v,u,w],
NewSparseMultivariatePolynomial(Integer,
OrderedVariableList [b1,x,y,z,t,v,u,w]))
We have obtained one regular chain (i.e. regular triangular set) with
dimension 1. This set is in fact a characterist set of the (radical
of) of the ideal generated by the input system lf. Thus we have
only the generic points of the variety associated with lf
(for the elimination ordering given by ls).
So let us get now a full description of this variety.
Hence, we solve this system in the sense of Lazard by means of the REGSET
constructor:
|
|
Type: List
RegularTriangularSet(Integer,
IndexedExponents OrderedVariableList [b1,x,y,z,t,v,u,w],
OrderedVariableList [b1,x,y,z,t,v,u,w],
NewSparseMultivariatePolynomial(Integer,
OrderedVariableList [b1,x,y,z,t,v,u,w]))
We retrieve our regular chain of dimension 1 and we get three regular
chains of dimension 0 corresponding to the degenerated cases.
We want now to simplify these zero-dimensional regular chains by using
Lazard triangular sets. Moreover, this will allow us to prove that
the above decomposition has no redundant component. N.B.
Generally, decompositions computed by the REGSET constructor do
not have redundant components. However, to be sure that no redundant
component occurs one needs to use the SREGSET or LAZM3PK
constructors.
So let us solve the input system in the sense of Lazard by means of
the LAZM3PK constructor:
zeroSetSplit(lf,false)$pack
|
|
Type: List
SquareFreeRegularTriangularSet(Integer,
IndexedExponents OrderedVariableList [b1,x,y,z,t,v,u,w],
OrderedVariableList [b1,x,y,z,t,v,u,w],
NewSparseMultivariatePolynomial(Integer,
OrderedVariableList [b1,x,y,z,t,v,u,w]))
Due to square-free factorization, we obtained now four
zero-dimensional regular chains. Moreover, each of them is normalized
(the initials are constant). Note that these zero-dimensional
components may be investigated further with the
ZeroDimensionalSolvePackage package constructor.