# ZeroDimensionalSolvePackage(R, ls, ls2)ΒΆ

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

convert: SquareFreeRegularTriangularSet(R, IndexedExponents OrderedVariableList ls2, OrderedVariableList ls2, NewSparseMultivariatePolynomial(R, OrderedVariableList ls2)) -> List NewSparseMultivariatePolynomial(R, OrderedVariableList ls2)

`convert(st)` returns the members of `st`.

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: List Polynomial R -> List List RealClosure Fraction R

`positiveSolve(lp)` returns the same as `positiveSolve(lp, false, false)`.

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, 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: List Polynomial R -> List List RealClosure Fraction R

`realSolve(lp)` returns the same as `realSolve(ts, false, false, false)`

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, 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.

triangSolve: List Polynomial R -> List RegularChain(R, ls)

`triangSolve(lp)` returns the same as `triangSolve(lp, 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: List Polynomial R -> List Record(complexRoots: SparseUnivariatePolynomial R, coordinates: List Polynomial R)

`univariateSolve(lp)` returns the same as `univariateSolve(lp, false, false, false)`.

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