Real Polynomial Systems
Introduction
A
real polynomial system is an expression constructed with polynomial equations and inequalities
combined using logical connectives and quantifiers
An occurrence of a variable
x inside
_{x} or
_{x} is called a bound occurrence; any other occurrence of
x is called a free occurrence. A variable
x is called a free variable of a real polynomial system if the system contains a free occurrence of
x. A real polynomial system is quantifier free if it contains no quantifiers.
An example of a real polynomial system with free variables
x,
y, and
z is the following
Any real polynomial system can be transformed to the
prenex normal form
where each
Q_{i} is
or
, and
(x_{1}, ..., x_{n};y_{1}, ..., y_{m}) is a quantifierfree formula called the quantifierfree part of the system.
Any quantifierfree real polynomial system can be transformed to the disjunctive normal form
where each
_{i, j} is a polynomial equation or inequality.
Reduce,
Resolve, and
FindInstance always put real polynomial systems in the prenex normal form, with quantifierfree parts in the disjunctive normal form, and subtract sides of equations and inequalities to put them in the form
In all of the real polynomial system solving tutorials, we will always assume the system has been transformed to this form.
Reduce can solve arbitrary real polynomial systems. For a system with free variables
x_{1}, ..., x_{n}, the solution (possibly after expanding
with respect to
) is a disjunction of terms of the form
where
B (x_{k};x_{1}, ..., x_{k1}) is one of
and
r_{1} and
r_{2} are algebraic functions (expressed using
Root objects or radicals) such that for all
x_{1}, ..., x_{k1} satisfying
B (x_{1};)B (x_{2};x_{1})...B (x_{k1};x_{1}, ..., x_{k2}),
r_{1}and
r_{2} are well defined (that is, denominators and leading terms of
Root objects are nonzero), real valued, continuous, and satisfy inequality
r_{1}<r_{2}.
The subset of
^{n} described by formula (
4) is called a
cell. The cells described by different terms of solution of a real polynomial system are disjoint.
This solves the system ( 1). The cells are represented in a nested form.
Out[1]=  

This defines a function expanding with respect to . 
Here is the solution of the system ( 1) written explicitly as a union of disjoint cells.
Out[5]=  

Resolve can eliminate quantifiers from arbitrary real polynomial systems. If no variables are specified in the input and all input polynomials are at most linear in the bound variables,
Resolve may be able to eliminate the quantifiers without solving the resulting system. Otherwise,
Resolve uses the same algorithm and gives the same answer as
Reduce.
This eliminates quantifiers from the system ( 1).
Out[6]=  

FindInstance can handle arbitrary real polynomial systems, giving instances of real solutions or an empty list for systems that have no solutions. If the number of instances requested is more than one, the instances are randomly generated from the full solution of the system and therefore may depend on the value of the
RandomSeed option. If one instance is requested and the system does not contain general (
) quantifiers, a faster algorithm producing one instance is used and the instance returned is always the same.
This finds a solution of the system ( 1).
Out[7]=  

The main general tool used in solving real polynomial systems is the
Cylindrical Algebraic Decomposition (CAD) algorithm (see, for example, [
1]). CAD for quantifierfree systems is available in
Mathematica directly as
CylindricalDecomposition. There are also several other algorithms used to solve special case problems.
Cylindrical Algebraic Decomposition
SemiAlgebraic Sets and Cell Decomposition
A subset of
^{n} is
semi
algebraic if it is a solution set of a quantifierfree real polynomial system. According to Tarski's theorem [
2], solution sets of arbitrary (quantified) real polynomial systems are semialgebraic.
Every semialgebraic set can be represented as a finite union of disjoint cells [
3] defined recursively as follows:
 A cell in is a point or an open interval
 A cell in ^{k} has one of the two forms
where
C_{k} is a cell in
^{k},
r is a continuous algebraic function,
r_{1} and
r_{2} are continuous algebraic functions or
 or
, and
r_{1}<r_{2} on
C_{k}.
By an algebraic function we mean a function
r:C_{k} for which there is a polynomial
In
Mathematica algebraic functions can be represented as
Root objects or radicals.
The CAD algorithm, introduced by Collins [
4], computes a cell decomposition of solution sets of arbitrary real polynomial systems. The objective of the original Collins algorithm was to eliminate quantifiers from a quantified real polynomial system and to produce an equivalent quantifierfree polynomial system. After finding a cell decomposition, the algorithm performed an additional step of finding an implicit representation of the semialgebraic set in terms of polynomial equations and inequalities in the free variables. The objective of
Reduce is somewhat different. Given a semialgebraic set presented by a real polynomial system, quantified or not,
Reduce finds a cell decomposition of the set, explicitly written in terms of algebraic functions.
While
Reduce may use other methods to solve the system,
CylindricalDecomposition gives a direct access to the CAD algorithm. For a quantifierfree real polynomial system,
CylindricalDecomposition gives a nested formula representing disjunction of cells in the solved form (
4). As in the output of
Reduce, the cells are disjoint and additionally are always ordered lexicographically with respect to ranges of the subsequent variables.
This finds a cell decomposition of an annulus.
Out[8]=  

The Projection Phase of the CAD Algorithm
Finding a cell decomposition of a semialgebraic set using the CAD algorithm consists of two phases, projection and lifting. In the projection phase, we start with the set
A_{n+m} of factors of the polynomials present in the quantifierfree part
(x_{1}, ..., x_{n};y_{1}, ..., y_{m}) of the system (
2) and eliminate variables one by one using a projection operator
P such that
Generally speaking, if all polynomials of
A_{k} have constant signs on a cell
C^{k}, then all polynomials of
A_{k+1} are delineable over
C, that is, each has a fixed number of real roots on
C as a polynomial in
t_{k+1}, the roots are continuous functions on
C, they have constant multiplicities, and two roots of two of the polynomials are equal either everywhere or nowhere in
C. Variables are ordered so that
This way the roots of polynomials of
A_{1}, ..., A_{n} are the algebraic functions needed in the construction of the cell decomposition of the semialgebraic set.
Several improvements have reduced the size of the original Collins projection. The currently best projection operator applicable in all cases is due to Hong [
5]; however, in most situations we can use a smaller projection operator given by McCallum [
6,
7], with an improvement by Brown [
8]. There are even smaller projection operators that can be applied in some special cases. When equational constraints are present, we can use the projection operator suggested by Collins [
9], and developed and proven by McCallum [
10,
11]. When there are no equations and only strict inequalities, and there are no free variables or we are interested only in the fulldimensional part of the semialgebraic set, we can use an even smaller projection operator described in [
12,
13]. For systems containing equational constraints that generate a zerodimensional ideal, Gröbner bases are used to find projection polynomials.
Mathematica uses the smallest of the previously mentioned projections that is appropriate for the given example. Whenever applicable, we use the equational constraints; otherwise, we attempt to use McCallum's projection with Brown's improvement. When the system does not turn out to be well oriented, we compute Hong's projection.
The Lifting Phase of the CAD Algorithm
In the lifting phase, we find a cell decomposition of the semialgebraic set. Generally speaking, although the actual details depend on the projection operator used, we start with cells in
^{1} consisting of all distinct roots of
A_{1} and the open intervals between the roots. We find a sample point in each of the cells and remove the cells whose sample points do not satisfy the system describing the semialgebraic set (the system may contain conditions involving only
t_{1}). Next we lift the cells to cells in
^{n}, one dimension at a time. Suppose we have lifted the cells to
^{k}. To lift a cell
C^{k} to
^{k+1}, we find the real roots of
A_{k+1} with
t_{1}, ..., t_{k} replaced with the coordinates of the sample point
c in
C. Since the polynomials of
A_{k+1} are delineable on
C, each root
r is a value of a continuous algebraic function at
c, and the function can be represented as a
p^{th} root of a polynomial
fA_{k+1} such that
r is the
p^{th} root of
f (c, t_{k+1}). Now the lifting of the cell
C to
^{k+1} will consist of graphs of these algebraic functions and of the slices of
C×
between the subsequent graphs. The sample points in each of the new cells will be obtained by adding the
k+1^{st} coordinate to
c, equal to one of the roots, or to a number between two subsequent roots. As in the first step, we remove those lifted cells whose sample points do not satisfy the system describing the semialgebraic set.
If
k≥n,
t_{k+1}=y_{l} is a quantifier variable and we may not need to construct all the lifted cells. All we need is to find the (necessarily constant) truth value of
Q_{lyl}Q_{l+1yl+1}... Q_{mym} on
C. If
Q_{l}=, we know that the value is
True as soon as the truth value of
Q_{l+1yl+1}... Q_{mym} on one of the lifted cells is
True. If
Q_{l}=, we know that the value is
False as soon as the truth value of
Q_{l+1yl+1}... Q_{mym} on one of the lifted cells is
False.
The coefficients of sample points computed this way are in general algebraic numbers. To save costly algebraic number computations,
Mathematica uses arbitraryprecision floatingpoint number (
Mathematica "bignum") approximations of the coefficients, whenever the results can be validated. Note that using approximate arithmetic may be enough to prove that two roots of a polynomial or a pair of polynomials are distinct, and to find a nonzero sign of a polynomial at a sample point. What we cannot prove with approximate arithmetic is that two roots of a polynomial or a pair of polynomials are equal, or that a polynomial is zero at a sample point. However, we can often use information about the origins of the cell to resolve these problems. For instance, if we know that the resultant of two polynomials vanishes on the cell, and these two polynomials have exactly one pair of complex roots that can be equal within the precision bounds, we can conclude that these roots are equal. Similarly, if the last coordinate of a sample point was a root of a factor of the given polynomial, we know that this polynomial is zero at the sample point. If we cannot resolve all the uncertainties using the collected information about the cell, we compute the exact algebraic number values of the coordinates. For more details, see [
14,
24].
Decision Problems, FindInstance, and Assumptions
A
decision problem is a system with all variables existentially quantified, that is, a system of the form
where
x_{1}, ..., x_{n} are all variables in
. Solving a decision problem means deciding whether it is equivalent to
True or to
False, that is, deciding whether the quantifierfree system of polynomial equations and inequalities
(x_{1}, ..., x_{n}) has solutions.
All algorithms used by
Mathematica to solve real polynomial decision problems are capable of producing a point satisfying
(x_{1}, ..., x_{n}) if the system has solutions. Therefore the algorithms discussed in this section are used not only in
Reduce and
Resolve for decision problems, but also in
FindInstance, whenever a single instance is requested and the system is quantifier free or contains only existential quantifiers. The algorithms discussed here are also used for inference testing by
Mathematica functions using assumptions such as
Simplify,
Refine,
Integrate, and so forth.
Solving this decision problem proves that the set S={ (x, y)^{2}:x^{4}+y^{4}2xy≤1} contains the disk of radius 4/5 centered at the origin.
Out[9]=  

This shows that S does not contain the unit disk and provides a counterexample: a point in the unit disk that does not belong to S.
Out[10]=  

The primary method that allows
Mathematica to solve arbitrary real polynomial decision problems is the
Cylindrical Algebraic Decomposition (CAD) algorithm. There are, however, several other special case algorithms that provide much better performance in cases in which they are applicable.
When all polynomials are linear with rational number or floatingpoint number coefficients,
Mathematica uses a method based on the Simplex linear programming method. For other linear systems,
Mathematica uses a variant of the LoosWeispfenning linear quantifier elimination algorithm [
15]. When the system contains no equations and only strict inequalities, a faster "generic" version of CAD is used [
12,
13]. For systems containing equational constraints that generate a zerodimensional ideal,
Mathematica uses Gröbner bases to find a solution. For nonlinear systems with floatingpoint number coefficients, an inexact coefficient version of CAD [
16] is used.
There are also some special case methods that can be used as preprocessors to other decision methods. When the system contains an equational constraint linear with a constant coefficient in one of the variables, the constraint is used to eliminate the linear variable. If there is a variable that appears in the system only linearly with constant coefficients, the variable is eliminated using the LoosWeispfenning linear quantifier elimination algorithm [
15]. If there is a variable that appears in the system only quadratically, the quadratic case of Weispfenning's quantifier elimination by virtual substitution algorithm [
22,
23] could be used to eliminate the variable. For some examples this gives a substantial speedup; however, quite often it results in a significant slowdown. By default, the algorithm is not used as a preprocessor. Setting the system option
QVSPreprocessor in the
InequalitySolvingOptions group to
True makes
Mathematica use it.
There are two other special cases of real decision algorithms available in
Mathematica. An algorithm by Aubry, Rouillier, and Safey El Din [
17] applies to systems containing only equations. There are examples for which the algorithm performs much better than CAD; however, for randomly chosen systems of equations, it seems to perform significantly worse; therefore, it is not used by default. Setting the system option
ARSDecision in the
InequalitySolvingOptions group to
True causes
Mathematica to use the algorithm. Another algorithm by G. X. Zeng and X. N. Zeng [
18] applies to systems that consist of a single strict inequality. Again, the algorithm is faster than CAD for some examples, but slower in general; therefore, it is not used by default. Setting the system option
ZengDecision in the
InequalitySolvingOptions group to
True causes
Mathematica to use the algorithm.
Arbitrary Real Polynomial Systems
Solving Real Polynomial Systems
According to Tarski's theorem [
2], the solution set of an arbitrary (quantified) real polynomial system is a semialgebraic set.
Reduce gives a description of this set in the solved form (
4).
This shows for what r>0 the set S={ (x, y)^{2}:x^{4}+y^{4}2xy≤1} contains the disk of radius r centered at the origin.
Out[11]=  

This gives the projection of x^{2}+y^{2}+z^{2}xyz≤1 on the (x, y) plane along the z axis.
Out[12]=  

This finds the projection of Whitney's umbrella x^{2}y^{2}z=0 on the (y, z) plane along the x axis.
Out[13]=  

Here we find the interior of the previous projection set by directly using the definition.
Out[14]=  

Quantifier Elimination
The objective of
Resolve with no variables specified is to eliminate quantifiers and produce an equivalent quantifierfree formula. The formula may or may not be in a solved form, depending on the algorithm used.
Producing a fully solved quantifierfree formula here is difficult because of the complexity of polynomials in a, b, and c appearing in the input. However, since x appears in the input polynomials only linearly, the quantifier can be quickly eliminated using the LoosWeispfenning linear quantifier elimination algorithm, which depends very little on the complexity of coefficients.
Out[15]=  

Algorithms
The primary method used by
Mathematica for solving real polynomial systems and real quantifier elimination is the CAD algorithm. There are, however, simpler methods applicable in special cases.
If the system contains an equational constraint in a variable from the innermost quantifier, the constraint is used to simplify the system using the identity
Note that if
a or
b is a nonzero constant, this eliminates the variable
y.
If all polynomials in the system are linear in a variable from the innermost quantifier, the variable is eliminated using the LoosWeispfenning linear quantifier elimination algorithm [
15].
If all polynomials in the system are at most quadratic in a variable from the innermost quantifier, the variable is eliminated using the quadratic case of Weispfenning's quantifier elimination by virtual substitution algorithm [
22,
23]. With the default setting of the system option
QuadraticQE, the algorithm is used for
Resolve with no variables specified and with at least two parameters present, and for
Reduce and
Resolve with at least three variables as long as elimination of one variable at most doubles the
LeafCount of the system.
The CAD algorithm is used when the previous three special case methods are no longer applicable, but there are still quantifiers left to eliminate or a solution is required.
For systems containing equational constraints that generate a zerodimensional ideal,
Mathematica uses Gröbner bases to find the solution set.
Options
The
Mathematica functions for solving real polynomial systems have a number of options that control the way that they operate. This section gives a summary of these options.
  
Cubics  False  whether the Cardano formulas should be used to express numeric solutions of cubics 
Quartics  False  whether the Cardano formulas should be used to express numeric solutions of quartics 
WorkingPrecision   the working precision to be used in computations 
Reduce, Resolve, and FindInstance options affecting the behavior for real polynomial systems.
Cubics and Quartics
By default, Reduce does not use the Cardano formulas for solving cubics or quartics over the reals.
Out[16]=  

Solutions of cubics and quartics involving parameters will still be represented using Root objects.
Out[18]=  

This is because the Cardano formulas do not separate real solutions from nonreal ones. For instance, in this case, for a=1 the third radical solution is real, but for a=1 the first radical solution is real.
Out[19]=  
Out[20]=  

WorkingPrecision
The setting of
WorkingPrecision affects the
lifting phase of the CAD algorithm. With a finite working precision
prec, sample points in the first variable lifted are represented as arbitraryprecision floatingpoint numbers with
prec digits of precision. When we compute sample points for subsequent variables, we find roots of polynomials whose coefficients depend on already computed sample point coordinates and therefore may be inexact. Hence coordinates of sample points will have precision
prec or lower. Determining the sign of polynomials at sample points is simply done by evaluating
Sign of the floatingpoint number obtained after the substitution. Using a finite
WorkingPrecision may allow getting the answer faster; however, the answer may be incorrect or the computation may fail due to loss of precision.
This problem is too hard for Reduce working in infinite WorkingPrecision, due to the high degrees of the algebraic numbers involved. Using sample points with 30 digits of precision gives a solution in under two seconds.
Out[21]=  

ReduceOptions Group of System Options
Here are the system options from the
ReduceOptions group that may affect the behavior of
Reduce,
Resolve, and
FindInstance for real polynomial systems. The options can be set with
  
"FactorInequalities"  False  whether inequalities should be factored at the input preprocessing stage 
"ReorderVariables"  False  whether Reduce and Resolve are allowed to reorder the specified variables 
ReduceOptions group options affecting the behavior of Reduce, Resolve, and FindInstance for real polynomial systems.
FactorInequalities
at the input preprocessing stage may speed up the computations in some cases. In general, however, it does not make the problem easier to solve, and, in some cases, it may make the problem significantly harder. By default, these transformations are not used.
Using transformations ( 7) speeds up the first example; however, it makes the other two examples significantly slower. The second example suffers from exponential growth of the number of inequalities. By replacing y^{7}≥0 with y≥0 in the third example, we get a degree21 system in y instead of a degree3 system in y^{7}.
Out[28]=  

ReorderVariables
By default, Reduce is not allowed to reorder the specified variables. Variables appearing earlier in the variable list may be used to express solutions for variables appearing later in the variable list, but not vice versa.
Out[30]=  

Setting the system option ReorderVariables>True allows Reduce to pick a variable order that makes the system easier to solve.
Out[32]=  

InequalitySolvingOptions Group of System Options
Here are the system options from the
InequalitySolvingOptions group that may affect the behavior of
Reduce,
Resolve, and
FindInstance for real polynomial systems. The options can be set with
  
"ARSDecision"  False  whether to use the decision algorithm given in [] 
"BrownProjection"  True  whether the CAD algorithm should use the improved projection operator given in [] 
"CAD"  True  whether to use the CAD algorithm 
"CADDefaultPrecision"  30.103  the precision to which nonrational roots are computed in the lifting phase of the CAD algorithm; if computation with approximate roots cannot be validated, the algorithm reverts to exact algebraic number computation 
"CADSortVariables"  True  whether the CAD algorithm should use variable reordering heuristics for quantifier variables within a single quantifier or in decision problems 
"CADZeroTest"  {0,}  determines the zero testing method used by the CAD algorithm for expressions obtained by evaluating polynomials at points with algebraic number coordinates 
"ContinuedFractionRootIsolation" 
 True  whether the CAD algorithm should use a real root isolation method based on continued fractions rather than on interval bisection [] 
"EquationalConstraintsCAD"  Automatic  whether the projection phase of the CAD algorithm should use equational constraints; with the default Automatic setting the operator proven correct in [] is used; if True the unproven projection operator using multiple equational constraints suggested in [] is used 
"FGLMBasisConversion"  False  whether the CAD algorithm should use a Gröbner basis conversion algorithm based on [] to find univariate polynomials in zerodimensional Gröbner bases; otherwise, GroebnerWalk is used 
"FGLMElimination"  Automatic  whether the decision and quantifier elimination algorithms for systems with equational constraints forming a zerodimensional ideal should use an algorithm based on [] to look for linear equation constraints (with constant leading coefficients) in one of the variables to be used for elimination 
"GenericCAD"  True  whether to use the variant of the CAD algorithm described in [] for decision and optimization problems 
"GroebnerCAD"  True  whether the CAD algorithm for systems with equational constraints forming a zerodimensional ideal should use Gröbner bases as projection 
"LinearDecisionMethodCrossovers" 
 {0,30,20}  determines methods used to find solutions of systems of linear equations and inequalities with rational number coefficients 
"LinearEquations"  True  whether to use linear equation constraints (with constant leading coefficients) to eliminate variables in decision problems 
"LinearQE"  True  whether to use the LoosWeispfenning linear quantifier elimination algorithm [] for quantifier elimination problems 
"LWDecision"  True  whether to use the LoosWeispfenning linear quantifier elimination algorithm [] for decision problems with linear inequality systems 
"LWPreprocessor"  Automatic  whether to use the LoosWeispfenning linear quantifier elimination algorithm [] as a preprocessor for the decision problems 
"ProjectAlgebraic"  Automatic  whether the CAD algorithm should compute projections with respect to variables replacing algebraic number coefficients or use their minimal polynomials instead 
"ProveMultiplicities"  True  determines the way in which the lifting phase of the CAD algorithm validates multiple roots and zero leading coefficients of projection polynomials 
"QuadraticQE"  Automatic  whether to use the quadratic case of Weispfenning's quantifier elimination by virtual substitution algorithm in quantifier elimination 
"QVSPreprocessor"  False  whether to use the quadratic case of Weispfenning's quantifier elimination by virtual substitution algorithm as a preprocessor for the decision problems 
"ReducePowers"  True  whether to replace x^{d} with x in the input to the CAD, where d is the GCD of all exponents of x in the system 
"RootReduced"  False  whether the coordinates of solutions of systems with equational constraints forming a zerodimensional ideal should be reduced to single Root objects 
"Simplex"  True  whether to use the Simplex algorithm in the decision algorithm for linear inequality systems 
"ThreadOr"  True  whether to solve each case of disjunction separately in decision problems, optimization, and in quantifier elimination of existential quantifiers when the quantifier free system does not need to be solved 
"ZengDecision"  False  whether to use the decision algorithm given in [] 
InequalitySolvingOptions group options affecting the behavior of Reduce, Resolve, and FindInstance for real polynomial systems.
ARSDecision
The option ARSDecision specifies whether Mathematica should use the algorithm by Aubry, Rouillier, and Safey El Din [ 17]. The algorithm applies to decision problems containing only equations. There are examples for which the algorithm performs much better than the CAD algorithm; however, for randomly chosen systems of equations it seems to perform significantly worse. Therefore it is not used by default. Here is a decision problem (referred to as butcher8 in the literature), which is not done by CAD in 1000 seconds, but which can be done quite fast by the algorithm given in [ 17].
Out[34]=  

BrownProjection
By default, the Mathematica implementation of the CAD algorithm uses Brown's improved projection operator [ 8]. The improvement usually speeds up computations substantially. There are some cases where using Brown's projection operator results in a slight slowdown. The option BrownProjection specifies whether Brown's improvement should be used. In the first example [ 21], using Brown's improved projection operator results in a speedup by a factor of 3; in the second, it results in a 40% slowdown.
Out[40]=  
Out[44]=  

CAD
The option CAD specifies whether Mathematica is allowed to use the CAD algorithm. With CAD set to False, computations that require CAD will fail immediately instead of attempting the high complexity CAD computation. With CAD enabled, this computation is not done in 1000 seconds.
Out[47]=  

CADDefaultPrecision
By default, Mathematica uses validated numeric computations in the lifting phase of the CAD algorithm, reverting to exact algebraic number computations only if the numeric computations cannot be validated [ 14]. The option CADDefaultPrecision specifies the initial precision with which the sample point coordinates are computed. Choosing the value of CADDefaultPrecision is a tradeoff between speed of numeric computations and the number of points where the algorithm reverts to exact computations due to precision loss. With the default value of 100 bits, the cases where the algorithm needs to revert to exact computations due to precision loss seem quite rare. Setting CADDefaultPrecision to Infinity causes Mathematica to use exact algebraic number computations in the lifting phase of CAD. Here is an example that runs fastest with the lowest CADDefaultPrecision setting. (Specifying values lower than 16.2556 (54 bits) results in CADDefaultPrecision being set to 16.2556.) With CADDefaultPrecision>Infinity, the example did not finish in 1000 seconds.
Out[49]=  
Out[51]=  

CADSortVariables
The performance of the CAD algorithm often depends quite strongly on the order of variables used. Some aspects of the variable ordering are fixed by the problem we are solving: quantifier variables need to be projected before free variables, and variables from innermost quantifiers need to be projected first. Variables specified in Reduce and Resolve cannot be reordered unless ReorderVariables is set to True. This, however, still leaves some freedom in ordering of variables: variables from the same quantifier can be reordered, and so can be variables given to FindInstance. By default, Mathematica uses a variable ordering heuristic to determine the order of these variables. In most cases the heuristic improves the performance of CAD; in some examples, however, the heuristic does not pick the best ordering. Setting CADSortVariables to False disables the heuristic and the order of variables used is as given in the quantifier variable list or in the variable list argument to FindInstance. Here is an example [ 21] that without reordering of quantified variables does not finish in 1000 seconds.
Out[53]=  

This shows the optimal variable ordering for the example.
Out[55]=  

CADZeroTest
One of the most timeconsuming operations in the
lifting phase of the CAD algorithm is determining the sign of a polynomial evaluated at a sample point with algebraic number coordinates. We try to avoid the problem by using sample points with arbitraryprecision floatingpoint number coordinates and keeping track of the "genealogy" of projection polynomials and sample points in order to validate the results. However, if some of the results cannot be validated, we have to revert to computations with exact algebraic number coordinates. To determine the sign of a polynomial evaluated at a sample point with algebraic number coordinates, we first evaluate the polynomial at numeric approximations of the algebraic numbers. If the result is nonzero (that is, zero is not within the error bounds of the resulting bignum), we know the sign. Otherwise, we need to test whether a polynomial expression in algebraic numbers is zero. The value of the
CADZeroTest option specifies what zero testing method should be used at this moment. The value should be a pair
{t, acc}. With the default value
t=0, Mathematica computes an accuracy
eacc such that if the expression is zero up to this accuracy, it must be zero. If
eacc≤acc, the value of the expression is computed up to accuracy
eacc and its sign is checked. Otherwise, the expression is represented as a single
Root object using
RootReduce and the sign of the
Root object is found. With the default value
acc=, we revert to
RootReduce if
eacc>$MaxPrecision. If
t=1,
RootReduce is always used. If
t=2, expressions that are zero up to accuracy
acc are considered zero. This is the fastest method, but, unlike the other two, it may give incorrect results because expressions that are nonzero but close to zero may be treated as zero.
This example runs faster with the CAD algorithm using the 30 digits of accuracy numeric zero test. The result in this example is correct; however, this setting of CADZeroTest may lead to incorrect results.
Out[60]=  

ContinuedFractionRootIsolation
To isolate real roots of polynomials,
Mathematica uses methods based on Descartes' rule of sign. There are two interval subdivision strategies implemented, one based on interval bisection and another based on continued fractions (see [
19] for details). The variant based on continued fractions is generally faster and is used by default. Setting
ContinuedFractionRootIsolation to
False causes
Mathematica to use the interval bisection variant.
Here is an example where the speed difference between the two root isolation methods affects Reduce timing. We need to clear the Root cache between the Reduce calls; otherwise, the second call would save time on factoring the 400 ^{th} degree polynomial when Root objects are created.
Out[68]=  

EquationalConstraintsCAD
The
EquationalConstraintsCAD option specifies whether the projection phase of the CAD algorithm should use equational constraints. With the default setting
Automatic,
Mathematica uses the projection operator proven correct in [
11]. With
EquationalConstraintsCAD>True, the smaller but unproven projection operator suggested in [
4] is used.
Here we find an instance satisfying the system using the CAD algorithm with EquationalConstraintsCAD>True. Even though the method used to find the solution was based on an unproven conjecture, the solution is proven to be correct, that is, it satisfies the input system.
Out[71]=  

With the default setting EquationalConstraintsCAD>Automatic, finding a solution of this system takes more than twice as long.
Out[73]=  

With EquationalConstraintsCAD>False, finding a solution of this system again takes almost twice as long.
Out[75]=  

Here FindInstance shows that the system has no solutions. Since it is using the CAD algorithm with EquationalConstraintsCAD>True, the correctness of the answer depends on an unproven conjecture.
Out[77]=  

With the default setting EquationalConstraintsCAD>Automatic, proving that the system has no solutions takes longer, but the answer is known to be correct.
Out[79]=  

FGLMBasisConversion
For systems with equational constraints generating a zerodimensional ideal
I,
Mathematica uses a variant of the CAD algorithm that finds projection polynomials using Gröbner basis methods. If the lexicographic order Gröbner basis of
I does not contain linear polynomials with constant coefficients in every variable but the last one, then for every variable
x_{i} we find a univariate polynomial in
x_{i} that belongs to
I.
Mathematica can do this in two ways. By default, it uses a method based on
GroebnerWalk computations. Setting
FGLMBasisConversion to
True causes
Mathematica to use a method based on [
20].
The method based on [ 20] seems to be slightly slower in general.
Out[83]=  

FGLMElimination
The
FGLMElimination option specifies whether
Mathematica should use a special case heuristic applicable to systems with equational constraints generating a zerodimensional ideal
I. The heuristic uses a method based on [
20] to find in
I polynomials that are linear (with a constant coefficient) in one of the quantified variables and uses such polynomials for elimination. The method can be used both in the decision algorithm and in quantifier elimination. With the default
Automatic setting, it is used only in
Resolve with no "solve" variables specified and for systems with at least two free variables.
This by default uses the elimination method based on [ 20], and returns a quantifierfree system in an unsolved form.
Out[85]=  

With FGLMElimination set to False, the example takes longer to compute and the answer is in a solved form. (We show N of the answer for better readability.)
Out[87]=  

If there is only one free variable, Resolve by default does not use the elimination method based on [ 20]. (We show N of the answer for better readability.)
Out[89]=  

With FGLMElimination set to True, the example takes longer to compute and the answer is given in an unsolved form.
Out[91]=  

GenericCAD
Mathematica uses a simplified version of the CAD algorithm described in [
13] to solve decision problems or find solutions of real polynomial systems that do not contain equations. The method finds a solution or proves that there are no solutions if all inequalities in the system are strict (
< or
>). The method is also used for systems containing weak (
<= or
>=) inequalities. In this case, if it finds a solution of the strict inequality version of the system, it is also a solution of the original system. However, if it proves that the strict inequality version of the system has no solutions, the full version of the CAD algorithm is needed to decide whether the original system has solutions. The system option
GenericCAD specifies whether
Mathematica should use the method.
Here the GenericCAD method finds a solution of the strict inequality version of the system.
Out[93]=  

Without GenericCAD, finding a solution of the system takes much longer.
Out[95]=  

This system has no solutions and contains weak inequalities. After the GenericCAD method finds no solutions of the strict inequality version of the system, Mathematica needs to run the full CAD to prove that there are no solutions.
Out[97]=  

Running the same example with GenericCAD>False allows to save the time previously used by the GenericCAD computation.
Out[99]=  

This system contains only strict inequalities, so GenericCAD can prove that it has no solutions.
Out[101]=  

Without GenericCAD, it takes much longer to prove that the system has no solutions.
Out[103]=  

GroebnerCAD
For systems with equational constraints generating a zerodimensional ideal
I,
Mathematica uses a variant of the CAD algorithm that finds projection polynomials using Gröbner basis methods. Setting
GroebnerCAD to
False, causes
Mathematica to use the standard CAD projection instead.
This checks that the solutions are equivalent.
Out[108]=  

LinearDecisionMethodCrossovers, LWDecision, and Simplex
These three options specify methods used to solve decision problems or find solution instances for systems of linear equations and inequalities. The available methods are the LoosWeispfenning algorithm [
15], the Simplex algorithm, and the Revised Simplex algorithm. All three methods can handle systems with rational or floatingpoint number coefficients. For systems with exact numeric nonrational coefficients, only the LoosWeispfenning algorithm is implemented.
LWDecision specifies whether the LoosWeispfenning algorithm is available.
Simplex specifies whether the Simplex and Revised Simplex algorithms can be used.
LinearDecisionMethodCrossovers determines which method is used if all are available and applicable. The value of the option should be a triple
{m, n, p}. For linear systems with up to
m variables,
Mathematica uses the LoosWeispfenning method [
15]; for systems with
m+1 to
n variables, the Simplex algorithm; and for more than
n variables, the Revised Simplex algorithm. If the Simplex algorithm is used, the slack variables are used if the number of inequalities is no more than
p times the number of variables. The default values are
m=0,
n=30, and
p=20.
By default, the Simplex algorithm is used to find a solution of a linear system with three variables.
Out[110]=  

Here the Revised Simplex algorithm is used.
Out[112]=  

Here the LoosWeispfenning algorithm is used.
Out[114]=  

Here the LoosWeispfenning algorithm is used because the Simplex and Revised Simplex algorithms are not implemented for systems with exact nonrational coefficients.
Out[116]=  

With LWDecision set to False, and Simplex and Revised Simplex not applicable, FindInstance has to use the CAD algorithm here.
Out[118]=  

LinearEquations
The
LinearEquations option specifies whether linear equation constraints with constant leading coefficients should be used to eliminate variables. This generally improves the performance of the algorithm. The option is provided to allow experimentation with the "pure" CADbased decision algorithm.
Here Mathematica uses the first equation to eliminate x before using CAD to find a solution of the resulting system with two variables.
Out[120]=  

Here Mathematica uses CAD to find a solution of the original system with three variables.
Out[122]=  

LinearQE
The
LinearQE option specifies methods used to handle systems containing at least one innermost quantifier variable that appears at most linearly in all equations and inequalities in the system. The option setting does not affect solving of decision problems. With the default setting
True,
Mathematica uses the LoosWeispfenning algorithm [
15] to eliminate all quantifier variables that appear only linearly in the system, and then if there are any quantifiers left or the result needs to be solved for the free variables, the CAD algorithm is used. With
LinearQE>Automatic, the LoosWeispfenning algorithm is used only for variables that appear in the system only linearly with constant coefficients. With
LinearQE>False, the LoosWeispfenning algorithm is not used.
With the default setting LinearQE>True, the LoosWeispfenning algorithm is used to eliminate both x and y, and CAD is used to solve the remaining quantifierfree system with two variables.
Out[125]=  

With LinearQE>Automatic, the LoosWeispfenning algorithm is used only to eliminate x, and CAD is used to solve the remaining system with three variables. For this example, the default method is much faster.
Out[128]=  

With LinearQE>False, the LoosWeispfenning algorithm is not used. Reduce uses CAD to solve the original system with four variables, which for this example takes much longer.
Out[130]=  

All three methods give the same answer.
Out[131]=  

Here is an example where the default method is not the fastest. With the default setting LinearQE>True, the LoosWeispfenning algorithm is used to eliminate both x and y, and CAD is used to solve the remaining system with one quantified and one free variable.
Out[133]=  

With LinearQE>Automatic, the LoosWeispfenning algorithm is used only to eliminate x, and then CAD is used to solve the remaining system with two quantified variables and one free variable. This is the fastest method for this example.
Out[135]=  

With LinearQE>False, the CAD algorithm is used to solve the system.
Out[137]=  

The default setting LinearQE>True is definitely advantageous for quantifier elimination problems where all quantified variables appear only linearly in the system and the quantifierfree version of the system does not need to be given in a solved form. This is because the complexity of the LoosWeispfenning algorithm depends very little on the number of free variables, unlike the complexity of the CAD algorithm that is doubly exponential in the number of all variables. With LinearQE>False, this example does not finish in 1000 seconds.
Out[139]=  

LWPreprocessor
The
LWPreprocessor option setting affects solving decision problems and instance finding. The option specifies whether the LoosWeispfenning algorithm [
8] should be used to eliminate variables that appear at most linearly in all equations and inequalities before applying the CAD algorithm to the resulting system. With the default setting
Automatic,
Mathematica uses the LoosWeispfenning algorithm to eliminate variables that appear only linearly with constant coefficients. With
LWPreprocessor>True, the LoosWeispfenning algorithm is used for all variables that appear only linearly. With
LWPreprocessor>False, the LoosWeispfenning algorithm is not used as a preprocessor to the CADbased decision algorithm.
With the default setting LWPreprocessor>Automatic, the LoosWeispfenning algorithm is used only to eliminate x, and CAD is used to find a solution of the remaining system with three variables.
Out[140]=  

With LWPreprocessor>True, the LoosWeispfenning algorithm is used to eliminate both x and y, and CAD is used to find a solution of the remaining system with two variables. For this example, this method is slower than the default one.
Out[142]=  

With LWPreprocessor>False, the CAD algorithm is used to find a solution of the original system with four variables. For this example, this method is as fast as the default.
Out[144]=  

This example differs from the previous one only in that the last inequality was turned into an equation. With the default setting LWPreprocessor>Automatic, the LoosWeispfenning algorithm is only used to eliminate x, and CAD is used to find a solution of the remaining system with three variables.
Out[146]=  

With LWPreprocessor>True, the LoosWeispfenning algorithm is used to eliminate both x and y, and CAD is used to find a solution of the remaining system with two variables. For the revised example, this method is faster than the default one.
Out[148]=  

With LWPreprocessor>False, the CAD algorithm is used to find a solution of the original system with four variables. For the revised example, this is seven times slower than the default method.
Out[150]=  

ProjectAlgebraic
The setting of the
ProjectAlgebraic option affects handling of algebraic number coefficients in the CAD algorithm.
Algebraic numbers found in coefficients of the input system are replaced with new variables. The new variables are always put first in the variable ordering so that in the projection phase of the CAD algorithm they are eliminated last. When the current projection polynomials contain
k+1 variables with at least
k first variables replacing algebraic number coefficients, we have a choice of whether or not to continue the projection phase. If we do not continue the projection phase, we can start the lifting phase extending the zerodimensional cell in the first
k variables on which each of the variables is equal to the corresponding algebraic number coefficient. If we choose to compute the last
k projections, we may find in the lifting phase that the algebraic number coefficient corresponding to a variable being lifted lies between the roots of the projection polynomials. Hence for this variable we will be extending a onedimensional cell with a rational number sample point. Thus there is a tradeoff between avoiding computation of the last
k projections and avoiding algebraic number coordinates in sample points.
With
ProjectAlgebraic>True, the projection phase is continued for variables replacing algebraic number coefficients until there is one variable left. With
ProjectAlgebraic>False, the projection phase is stopped as soon as there is one variable left that does not replace an algebraic number coefficient. With the default setting
ProjectAlgebraic>Automatic, the projection phase is stopped if there is at most one variable left that does not replace an algebraic number coefficient and there are at least three projection polynomials, or there is a projection polynomial of degree more than two in the projection variable.
With few highdegree algebraic number coefficients, equations, and inequalities in the system, ProjectAlgebraics>True tends to be a better choice. ( N is applied to the output for better readability.)
Out[153]=  
Out[155]=  

With many lowdegree algebraic number coefficients, equations, and inequalities in the system, ProjectAlgebraics>False tends to be faster.
Out[157]=  
Out[159]=  

With ProjectAlgebraics>Automatic, Mathematica picks the faster method in the second example, but fails to pick the faster method in the first example.
Out[161]=  
Out[162]=  

ProveMultiplicities
The setting of
ProveMultiplicities determines the way in which the lifting phase of the CAD algorithm validates multiple roots and zero leading coefficients of projection polynomials obtained using arbitraryprecision floatingpoint number (
Mathematica "bignum") computations (for more details, see [
14,
24]). With the default setting
ProveMultiplicities>True,
Mathematica uses information about the origins of the cell, if this is not sufficient computes exact values of cell coordinates and uses principal subresultant coefficients and exact zero testing, and only if this fails reverts to exact computations. With
ProveMultiplicities>Automatic,
Mathematica uses information about the origins of the cell and, if this is not sufficient, reverts to exact computation. With
ProveMultiplicities>False,
Mathematica reverts to exact computation each time bignum computations fail to separate all roots or prove that the leading coefficients of projection polynomials are nonzero.
QuadraticQE
The
QuadraticQE option specifies whether the quadratic case of Weispfenning's quantifier elimination by virtual substitution algorithm [
22,
23] should be used to eliminate quantified variables that appear at most quadratically in all equations and inequalities in the system. The complexity of Weispfenning's algorithm depends very little on the number of free variables, unlike the complexity of the CAD algorithm that is doubly exponential in the number of all variables. Hence, it is definitely advantageous to use it when all quantifiers can be eliminated using the algorithm, there are many free variables present, and the quantifierfree version of the system does not need to be given in a solved form. On the other hand, eliminating a variable using Weispfenning's algorithm often significantly increases the size of the formula. So if
Mathematica needs to apply CAD to the result or if the system contains few free variables, using CAD on the original system may be faster. With the default setting
Automatic,
Mathematica uses the algorithm for
Resolve with no variables specified and with at least two parameters present, and for
Reduce and
Resolve with at least three variables as long as elimination of one variable at most doubles the
LeafCount of the system. This criterion seems to work reasonably well; however, for some examples it does not give the optimal choice of the algorithm. Changing the option value may allow problems to be solved which otherwise take a very long time. With
LinearQE>True, Weispfenning's algorithm is used whenever there is a quadratic variable to eliminate, with
LinearQE>False, Weispfenning's algorithm is not used.
Resolve with no variables specified and with at least two parameters present uses Weispfenning's algorithm to eliminate x. The result is not solved for the parameters a, b, and c.
Out[170]=  

Reduce by default uses CAD for this example. The result is solved for the parameters a, b, and c.
Out[171]=  

With QuadraticQE>True, Reduce uses Weispfenning's algorithm to eliminate x and then CAD to solve the quantifierfree formula for the parameters a, b, and c. In this example this is faster than the default method of using CAD from the beginning.
Out[173]=  

For this system with three free variables Weispfenning's algorithm works much better than CAD. With QuadraticQE>False, Resolve does not finish in 1000 seconds.
Out[175]=  

Weispfenning's algorithm is slower here and gives a more complicated result.
Out[177]=  

QVSPreprocessor
The
QVSPreprocessor option setting affects solving decision problems and instance finding. The option specifies whether the quadratic case of Weispfenning's quantifier elimination by virtual substitution algorithm [
22,
23] should be used to eliminate variables that appear at most quadratically in all equations and inequalities before applying the CAD algorithm to the resulting system. The default setting is
False and the algorithm is not used. There are examples where using Weispfenning's algorithm as a preprocessor significantly helps the performance, and there are examples where using the preprocessor significantly hurts the performance. It seems that the preprocessor tends to help in examples with many variables and where instances exist. With
QVSPreprocessor>True, Weispfenning's algorithm is used each time there is a quadratic variable. With
QVSPreprocessor>Automatic,
Mathematica uses the algorithm for systems with at least four variables.
Here Mathematica finds a solution using Weispfenning's algorithm as a preprocessor. Without the preprocessor this example takes 470 seconds.
Out[180]=  

This uses CAD to show that there are no solutions. With QVSPreprocessor>True this example does not finish in 1000 seconds, due to complexity of computing LogicalExpand for the generated large logical formulas.
Out[181]=  

ReducePowers
For any variable
x in the input to the CAD algorithm, if all powers of
x appearing in the system are integer multiples of an integer
k,
Mathematica replaces
x^{k} in the input system with a new variable, runs the CAD on the new system, and then resolves the answer so that it is expressed in terms of the original variables. Setting
ReducePowers>False turns off this shortcut. With
ReducePowers>False, the algebraic functions appearing as cell bounds in the output of the CAD algorithm are always rational functions, quadratic radical expressions, or
Root objects. With the default setting
ReducePowers>True, they may in addition be
e^{1/n} for any of the previous expressions
e,
or
Root[a#^{n}e&, 1] for some integer
a, and a rational function or a quadratic radical expression
e.
With the default setting ReducePowers>True, the CAD algorithm solves a quadratic equation in variables replacing x^{7} and y^{5}, and then the result is represented in terms of x and y. The result contains Root objects with quadratic radical expressions inside.
Out[182]=  

With ReducePowers>True, the CAD algorithm solves the original 14 ^{th} degree equation that takes several times longer. The result contains only Root objects with polynomial expressions inside.
Out[184]=  

RootReduced
For systems with equational constraints generating a zerodimensional ideal
I,
Mathematica uses a variant of the CAD algorithm that finds projection polynomials using Gröbner basis methods. If the lexicographic order Gröbner basis of
I contains linear polynomials with constant coefficients in every variable but the last one (which is true "generically"), then all coordinates of solutions are easily represented as polynomials in the last coordinate. Setting
RootReduced to
True causes
Mathematica to represent each coordinate as a single numeric
Root object. Computing this reduced representation often takes much longer than solving the system.
By default, we get the value of y expressed in terms of x.
Out[185]=  

With Backsubstitution>True, we get a numeric value of y, but the representation of the value is large.
Out[186]=  

Setting RootReduced>True causes Mathematica to represent the value of y as a single Root object. However, the computation takes ten times longer.
Out[188]=  

ThreadOr
The
ThreadOr option specifies how the identity
should be used in the decision algorithm (
Reduce and
Resolve for systems containing no free variables or parameters),
FindInstance, and quantifier elimination (
Resolve with no variables specified). With the default setting
ThreadOr>True, the identity (
8) is used before attempting any solution algorithms. With
ThreadOr>False, the identity (
8) may be used by algorithms that require using it (for instance, the Simplex algorithm), but will not be used by algorithms that do not require using it (for instance, the CAD algorithm).
Here Reduce finds an instance satisfying the first simpler term of Or, and hence avoids dealing with the second, more complicated, term.
Out[190]=  

With ThreadOr>False, Reduce needs to run a CADbased decision algorithm on the whole system.
Out[192]=  

This system has no solutions and so with ThreadOr>True Reduce needs to run a CADbased decision algorithm on each of the terms.
Out[194]=  

Since all six terms of Or involve exactly the same polynomials, running a CADbased decision algorithm on the whole expression consists of very similar computations as running a CADbased decision algorithm on one of the terms. In this case the computation with ThreadOr>False is faster.
Out[196]=  

ZengDecision
The option ZengDecision specifies whether Mathematica should use the algorithm by G. X. Zeng and X. N. Zeng [ 18]. The algorithm applies to decision problems with systems that consist of a single strict inequality. There are examples for which the algorithm performs better than the strict inequality variant of the CAD algorithm described in [ 13]. However, for randomly chosen inequalities, it seems to perform worse; therefore, it is not used by default. Here is an example from [ 18] that runs faster with ZengDecision>True.
Out[198]=  
Out[200]=  

References
[1] Caviness B. F. and J. R. Johnson, eds. Quantifier Elimination and Cylindrical Algebraic Decomposition: Texts and Monographs in Symbolic Computation. SpringerVerlag (1998)
[2] Tarski A. A Decision Method for Elementary Algebra and Geometry. University of California Press (1951)
[3] Łojasiewicz S. Ensembles SemiAnalytiques. Inst. Hautes Études Sci. (1964)
[4] Collins G. E. "Quantifier Elimination for the Elementary Theory of Real Closed Fields by Cylindrical Algebraic Decomposition" Lecture Notes in Computer Science 33 (1975): 134183
[5] Hong H. "An Improvement of the Projection Operator in Cylindrical Algebraic Decomposition" In Issac '90: Proceedings of the International Symposium on Symbolic and Algebraic Computation (M. Nagata, ed.), 261264, 1990
[6] McCallum S. "An Improved Projection for Cylindrical Algebraic Decomposition of Three Dimensional Space" J. Symb. Comput. 5, no. 1/2 (1988): 141161
[7] McCallum S. "An Improved Projection for Cylindrical Algebraic Decomposition" In Quantifier Elimination and Cylindrical Algebraic Decomposition: Texts and Monographs in Symbolic Computation (B. F. Caviness and J. R. Johnson, eds.). SpringerVerlag, 242268, 1998
[8] Brown C. W. "Improved Projection for Cylindrical Algebraic Decomposition" J. Symb. Comput. 32, no. 5 (2001): 447465
[9] Collins G. E. "Quantifier Elimination by Cylindrical Algebraic Decomposition—Twenty Years of Progress" In Quantifier Elimination and Cylindrical Algebraic Decomposition: Texts and Monographs in Symbolic Computation (B. F. Caviness and J. R. Johnson, eds.). SpringerVerlag, 823, 1998
[10] McCallum S. "On Projection in CADBased Quantifier Elimination with Equational Constraint" In Issac '99: Proceedings of the International Symposium on Symbolic and Algebraic Computation (Sam Dooley, ed.), 145149, 1999
[11] McCallum S. "On Propagation of Equational Constraints in CADBased Quantifier Elimination" In Issac 2001: Proceedings of the International Symposium on Symbolic and Algebraic Computation, 223231, 2001
[12] Strzebonski A. "An Algorithm for Systems of Strong Polynomial Inequalities" The Mathematica Journal 4, no. 4 (1994): 7477
[13] Strzebonski A. "Solving Systems of Strict Polynomial Inequalities" J. Symb. Comput. 29, no. 3 (2000): 471480
[14] Strzebonski A. "Cylindrical Algebraic Decomposition Using Validated Numerics" Paper presented at the ACA 2002 Session on SymbolicNumerical Methods in Computational Science, Volos, Greece (2002) (Notebook with the conference talk available at members.wolfram.com/adams)
[15] Loos R. and V. Weispfenning. "Applying Linear Quantifier Elimination" Comput. J. 36, no. 5 (1993): 450461
[16] Strzebonski A. "A Real Polynomial Decision Algorithm Using ArbitraryPrecision Floating Point Arithmetic" Reliable Comput. 5, no. 3 (1999): 337346; Developments in Reliable Computing (Tibor Csendes, ed.). Kluwer Academic Publishers (1999): 337346
[17] Aubry P., F. Rouillier, and M. Safey El Din. "Real Solving for Positive Dimensional Systems" J. Symb. Comput. 34, no. 6 (2002): 543560
[18] Zeng G. X. and X. N. Zeng. "An Effective Decision Method for Semidefinite Polynomials" J. Symb. Comput. 37, no. 1 (2004): 8399
[19] Akritas A. G. and A. Strzebonski. "A Comparative Study of Two Real Root Isolation Methods" Nonlinear Analysis: Modelling and Control 10, no. 4 (2005): 297304
[20] Faugere J. C., P. Gianni, D. Lazard, and T. Mora. "Efficient Computation of ZeroDimensional Gröbner Bases by Change of Ordering" J. Symb. Comput. 16, no. 4 (1993): 329344
[21] Dorato P., W. Yang, and C. Abdallah. "Robust MultiObjective Feedback Design by Quantifier Elimination" J. Symb. Comput. 24, no. 2 (1997): 153159
[22] Weispfenning V. "Quantifier Elimination for Real Algebra—The Cubic Case" In Issac 1994: Proceedings of the International Symposium on Symbolic and Algebraic Computation, 258263, 1994
[23] Weispfenning V. "Quantifier Elimination for Real Algebra—The Quadratic Case and Beyond" Appl. Algebra Eng. Commun. Comput. 8, no. 2 (1997): 85101
[24] Strzebonski A. "Cylindrical Algebraic Decomposition Using Validated Numerics" J. Symb. Comput. 41, no. 9 (2006): 10211038