SolveTools - Maple Programming Help

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Factorization and Solving Equations : SolveTools : SolveTools/PolynomialSystem





solve polynomial system of equations


Calling Sequence





Calling Sequence

PolynomialSystem(eqns, vars, notzero, options)




list or set; system of equations



(optional) list or set; variables for which to solve. The default is indets(eqns).



(optional) set; expressions for solutions not to be returned



(optional) equation(s) of the form keyword = value



backsubstitute = true or false


The default is true.  If false, a triangular set will be returned.  This can be much more compact than a solution that has been backsubstituted. Not compatible with domain=real or engine values other than groebner and triade.


engine = one of: default, groebner, traditional, triade, backsolve


Specify the method to use in solving.  If not specified, engine=default is used.


domain = one of: absolute, parametric, real


Specify the domain over which to solve. The default is absolute.


explicit = true or false


The default is false. If true, explicit, radical values for the roots are given where possible. Not compatible with backsubstitute=false.


maxsols = a non-negative integer or infinity


Specify the number of solutions to return. The default is infinity.


preprocess = true or false


If true, (the default) a series of simple preprocessors will be applied to the system to remove denominators of rational polynomial inputs, remove trivial equations, and remove simple linear equations before it is sent to the main polynomial solver.


preservelabels = true or false


The default is false. If true, labels will not be stripped from RootOfs.


tryhard = true or false


The default is true. If false, the engine will fail with an error if it determines that the solution will take a long time to compute.



The PolynomialSystem command solves a system of polynomial or rational equations, eqns, with respect to specified variables, vars. It is primarily intended for use on systems with more than one equation in more than one variable.  For a single equation or one variable, solve is preferred.  For linear equations, SolveTools[Linear] is preferred.


If notzero is specified, the PolynomialSystem command tries to not return solutions that make the given expressions zero. However, implicit solutions or parametric solutions that represent many solutions will still be returned unless all the solutions they represent cause the notzero equations to be zero. See the examples below.


By default the PolynomialSystem command uses a series of heuristics to choose the best engine with which to solve a system. Specifying engine=default will force this behavior.


Specifying engine=triade will use the Triangularize command of the RegularChains package to split the system.


Specifying engine=groebner will use the Basis command of the Groebner package to split the system.  Depending on the number of solutions a tdeg basis and a RationalUnivariateRepresentation will be computed instead of a plex basis.


Currently, the groebner and triade engines do not fully support polynomials with non-rational constants in the coefficients (such as radicals, RootOfs, or transcendental constants).


Specifying engine= traditional will use Maple library commands such as gcd, factor, and evala together with pseudo-subresultant computations to split the equations and find solutions efficiently.  This method may also call into the Groebner package if it cannot otherwise find solutions.


Specifying engine= backsolve will choose a method that will do as little work as possible on a system that is already in a regular triangular form.


If vars is given as a list, the triade and groebner engines will attempt to use the variable ordering in the list. That is, if there are fewer equations than variables, the solutions will be given with earlier variables specified in terms of later variables. Otherwise, if vars is a set, a good ordering will be chosen.


The domain option specifies the domain of the solution. By default the polynomials are solved over the algebraic closure of the coefficient field, C&conjugate0;a1,,am where ai are the symbols in the equations that are not variables.  It should be noted that the solution returned will not be valid for every possible specialization of the ai symbols. Specifying domain=absolute will force this behavior.


Specifying domain=real will return only real solutions to the equations.  This option is honored only when the system of equations has finitely many complex solutions.  Complex solutions may be returned for positive dimensional systems.


Specifying domain=parametric will also compute solutions over C&conjugate0;a1,,am but it will, with each solution, return a proviso inequality, that is, an inequality that must be satisfied by a substitution on the parameters for that substitution to lead to a valid solution.  Currently the parametric domain can not compute solutions with proviso for systems with an infinite number of solutions (positive dimensional systems) and attempting to solve such systems will result in an error.







PolynomialSystem([y-x^2+1, y+x^2-1], [x,y]);



PolynomialSystem([y-x^2+1, y+x^2-1], [x,y], {x<>1});



PolynomialSystem([y-x^2+1, y+x^2-1], [x,y], engine=groebner, backsubstitute=false);



PolynomialSystem([y-x^2+1, y+x^2-1], [x,y], engine=groebner);



PolynomialSystem([y^3+1,y+x^2-1], [x,y], domain=real);



PolynomialSystem([y^3+1,y+x^2-1], [x,y], engine=traditional);



PolynomialSystem([y^3+1,y+x^2-1], [x,y], engine=traditional, explicit=true);



PolynomialSystem([x^2-x,t*y-1,z-y], [x,y,z], domain=parametric);



The notzero optional argument cannot remove partial solutions:

PolynomialSystem({x-y, x^2-y^2, z+x}, {x,z}, {x-1});



PolynomialSystem({x^2-2, y^2-2}, {x,y}, {x-sqrt(2)});



notzero can remove whole components of parameterize solutions or individual RootOf branches of explicit solutions

PolynomialSystem({x^2-y^2, z+x}, {x,z}, {x-y});



PolynomialSystem({x^2-2, y^2-2}, {x,y}, {x-sqrt(2)}, explicit);



See Also