ZeroDimensionalSolvePackage(R, ls, ls2)

R : Join(OrderedRing, PolynomialFactorizationExplicit, CharacteristicZero, RealConstant)
ls : List(Symbol)
ls2 : List(Symbol)

A package for computing symbolically the complex and real roots of zero-dimensional algebraic systems over the integer or rational numbers. Complex roots are given by means of univariate representations of irreducible regular chains. Real roots are given by means of tuples of coordinates lying in the RealClosure of the coefficient ring. This constructor takes three arguments. The first one R is the coefficient ring. The second one ls is the list of variables involved in the systems to solve. The third one must be concat(ls, s) where s is an additional symbol used for the univariate representations. WARNING: The third argument is not checked. All operations are based on triangular decompositions. The default is to compute these decompositions directly from the input system by using the RegularChain domain constructor. The lexTriangular algorithm can also be used for computing these decompositions (see the LexTriangularPackage package constructor). For that purpose, the operations univariateSolve, realSolve and positiveSolve admit an optional argument. Author: Marc Moreno Maza.

convert : SquareFreeRegularTriangularSet(R, IndexedExponents(OrderedVariableList(ls2)), OrderedVariableList(ls2), NewSparseMultivariatePolynomial(R, OrderedVariableList(ls2))) -> List(NewSparseMultivariatePolynomial(R, OrderedVariableList(ls2))): convert(st) returns the members of st.

convert : NewSparseMultivariatePolynomial(R, OrderedVariableList(ls)) -> NewSparseMultivariatePolynomial(R, OrderedVariableList(ls2)): convert(q) converts q.

convert : NewSparseMultivariatePolynomial(R, OrderedVariableList(ls2)) -> Polynomial(RealClosure(Fraction(R))): convert(q) converts q.

convert : Polynomial(R) -> Polynomial(RealClosure(Fraction(R))): convert(p) converts p.

convert : SparseUnivariatePolynomial(R) -> SparseUnivariatePolynomial(RealClosure(Fraction(R))): convert(u) converts u.

positiveSolve : List(Polynomial(R)) -> List(List(RealClosure(Fraction(R)))): positiveSolve(lp) returns the same as positiveSolve(lp, false, false).

positiveSolve : (List(Polynomial(R)), Boolean) -> List(List(RealClosure(Fraction(R)))): positiveSolve(lp) returns the same as positiveSolve(lp, info?, false).

positiveSolve : (List(Polynomial(R)), Boolean, Boolean) -> List(List(RealClosure(Fraction(R)))): positiveSolve(lp, info?, lextri?) returns the set of the points in the variety associated with lp whose coordinates are (real) strictly positive. Moreover, if info? is true then some information is displayed during decomposition into regular chains. If lextri? is true then the lexTriangular algorithm is called from the LexTriangularPackage constructor (see zeroSetSplit(lp, false)). Otherwise, the triangular decomposition is computed directly from the input system by using the zeroSetSplit from RegularChain. WARNING: For each set of coordinates given by positiveSolve(lp, info?, lextri?) the ordering of the indeterminates is reversed w.r.t. ls.

positiveSolve : RegularChain(R, ls) -> List(List(RealClosure(Fraction(R)))): positiveSolve(ts) returns the points of the regular set of ts with (real) strictly positive coordinates.

realSolve : List(Polynomial(R)) -> List(List(RealClosure(Fraction(R)))): realSolve(lp) returns the same as realSolve(ts, false, false, false)

realSolve : (List(Polynomial(R)), Boolean) -> List(List(RealClosure(Fraction(R)))): realSolve(ts, info?) returns the same as realSolve(ts, info?, false, false).

realSolve : (List(Polynomial(R)), Boolean, Boolean) -> List(List(RealClosure(Fraction(R)))): realSolve(ts, info?, check?) returns the same as realSolve(ts, info?, check?, false).

realSolve : (List(Polynomial(R)), Boolean, Boolean, Boolean) -> List(List(RealClosure(Fraction(R)))): realSolve(ts, info?, check?, lextri?) returns the set of the points in the variety associated with lp whose coordinates are all real. Moreover, if info? is true then some information is displayed during decomposition into regular chains. If check? is true then the result is checked. If lextri? is true then the lexTriangular algorithm is called from the LexTriangularPackage constructor (see zeroSetSplit(lp, false)). Otherwise, the triangular decomposition is computed directly from the input system by using the zeroSetSplit from RegularChain. WARNING: For each set of coordinates given by realSolve(ts, info?, check?, lextri?) the ordering of the indeterminates is reversed w.r.t. ls.

realSolve : RegularChain(R, ls) -> List(List(RealClosure(Fraction(R)))): realSolve(ts) returns the set of the points in the regular zero set of ts whose coordinates are all real. WARNING: For each set of coordinates given by realSolve(ts) the ordering of the indeterminates is reversed w.r.t. ls.

squareFree : RegularChain(R, ls) -> List(SquareFreeRegularTriangularSet(R, IndexedExponents(OrderedVariableList(ls2)), OrderedVariableList(ls2), NewSparseMultivariatePolynomial(R, OrderedVariableList(ls2)))): squareFree(ts) returns the square-free factorization of ts. Moreover, each factor is a Lazard triangular set and the decomposition is a Kalkbrener split of ts, which is enough here for the matter of solving zero-dimensional algebraic systems. WARNING: ts is not checked to be zero-dimensional.

triangSolve : List(Polynomial(R)) -> List(RegularChain(R, ls)): triangSolve(lp) returns the same as triangSolve(lp, false, false)

triangSolve : (List(Polynomial(R)), Boolean) -> List(RegularChain(R, ls)): triangSolve(lp, info?) returns the same as triangSolve(lp, false)

triangSolve : (List(Polynomial(R)), Boolean, Boolean) -> List(RegularChain(R, ls)): triangSolve(lp, info?, lextri?) decomposes the variety associated with lp into regular chains. Thus a point belongs to this variety iff it is a regular zero of a regular set in in the output. Note that lp needs to generate a zero-dimensional ideal. If lp is not zero-dimensional then the result is only a decomposition of its zero-set in the sense of the closure (w.r.t. Zarisky topology). Moreover, if info? is true then some information is displayed during the computations. See zeroSetSplit(lp, true, info?). If lextri? is true then the lexTriangular algorithm is called from the LexTriangularPackage constructor (see zeroSetSplit(lp, false)). Otherwise, the triangular decomposition is computed directly from the input system by using the zeroSetSplit from RegularChain.

univariateSolve : List(Polynomial(R)) -> List(Record(complexRoots : SparseUnivariatePolynomial(R), coordinates : List(Polynomial(R)))): univariateSolve(lp) returns the same as univariateSolve(lp, false, false, false).

univariateSolve : (List(Polynomial(R)), Boolean) -> List(Record(complexRoots : SparseUnivariatePolynomial(R), coordinates : List(Polynomial(R)))): univariateSolve(lp, info?) returns the same as univariateSolve(lp, info?, false, false).

univariateSolve : (List(Polynomial(R)), Boolean, Boolean) -> List(Record(complexRoots : SparseUnivariatePolynomial(R), coordinates : List(Polynomial(R)))): univariateSolve(lp, info?, check?) returns the same as univariateSolve(lp, info?, check?, false).

univariateSolve : (List(Polynomial(R)), Boolean, Boolean, Boolean) -> List(Record(complexRoots : SparseUnivariatePolynomial(R), coordinates : List(Polynomial(R)))): univariateSolve(lp, info?, check?, lextri?) returns a univariate representation of the variety associated with lp. Moreover, if info? is true then some information is displayed during the decomposition into regular chains. If check? is true then the result is checked. See rur(lp, true). If lextri? is true then the lexTriangular algorithm is called from the LexTriangularPackage constructor (see zeroSetSplit(lp, false)). Otherwise, the triangular decomposition is computed directly from the input system by using the zeroSetSplit from RegularChain.

univariateSolve : RegularChain(R, ls) -> List(Record(complexRoots : SparseUnivariatePolynomial(R), coordinates : List(Polynomial(R)))): univariateSolve(ts) returns a univariate representation of ts. See rur(lp, true).