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