(directly go to documentation on : Solve, OldSolve, SuchThat, Eliminate, PSolve, MatrixSolve. )

# 12. Symbolic solvers

By solving one tries to find a mathematical object that meets certain criteria. This chapter documents the functions that are available to help find solutions to specific types of problems.

 Solve solve an equation OldSolve old version of Solve SuchThat special purpose solver Eliminate substitute and simplify PSolve solve a polynomial equation MatrixSolve solve a system of equations

### Solve -- solve an equation

##### Calling format:
 Solve(eq, var) 

##### Parameters:
eq -- equation to solve

var -- variable to solve for

##### Description:
This command tries to solve an equation. If eq does not contain the == operator, it is assumed that the user wants to solve $eq == 0$. The result is a list of equations of the form var == value, each representing a solution of the given equation. The Where operator can be used to substitute this solution in another expression. If the given equation eq does not have any solutions, or if Solve is unable to find any, then an empty list is returned.

The current implementation is far from perfect. In particular, the user should keep the following points in mind:

• Solve cannot solve all equations. If it is given a equation it can not solve, it raises an error via Check. Unfortunately, this is not displayed by the inline pretty-printer; call PrettyPrinter'Set to change this. If an equation cannot be solved analytically, you may want to call Newton to get a numerical solution.
• Systems of equations are not handled yet. For linear systems,
• MatrixSolve can be used. The old version of Solve, with the name OldSolve might be able to solve nonlinear systems of equations.
• The periodicity of the trigonometric functions
• Sin, Cos, and Tan is not taken into account. The same goes for the (imaginary) periodicity of Exp. This causes Solve to miss solutions.
• It is assumed that all denominators are nonzero. Hence, a solution reported by
• Solve may in fact fail to be a solution because a denominator vanishes.
• In general, it is wise not to have blind trust in the results returned by
• Solve. A good strategy is to substitute the solutions back in the equation.

##### Examples:
First a simple example, where everything works as it should. The quadratic equation $x ^{2} + x = 0$ is solved. Then the result is checked by substituting it back in the quadratic.

 In> quadratic := x^2+x; Out> x^2+x; In> Solve(quadratic, x); Out> {x==0,x==(-1)}; In> quadratic Where %; Out> {0,0}; 

If one tries to solve the equation $\exp \left( x\right) = \sin x$, one finds that Solve can not do this.

 In> PrettyPrinter'Set("DefaultPrint"); Out> True; In> Solve(Exp(x) == Sin(x), x); Error: Solve'Fails: cannot solve equation Exp(x)-Sin(x) for x Out> {}; 

The equation $\cos x = \frac{1}{2}$ has an infinite number of solutions, namely $x = \left( 2 k + \frac{1}{3} \right) \pi$ and $x = \left( 2 k - \frac{1}{3} \right) \pi$ for any integer $k$. However, Solve only reports the solutions with $k = 0$.

 In> Solve(Cos(x) == 1/2, x); Out> {x==Pi/3,x== -Pi/3}; 

For the equation $\frac{x}{\sin x} = 0$, a spurious solution at $x = 0$ is returned. However, the fraction is undefined at that point.

 In> Solve(x / Sin(x) == 0, x); Out> {x==0}; 

At first sight, the equation $\sqrt{x} = a$ seems to have the solution $x = a ^{2}$. However, this is not true for eg. $a = - 1$.

 In> PrettyPrinter'Set("DefaultPrint"); Out> True; In> Solve(Sqrt(x) == a, x); Error: Solve'Fails: cannot solve equation Sqrt(x)-a for x Out> {}; In> Solve(Sqrt(x) == 2, x); Out> {x==4}; In> Solve(Sqrt(x) == -1, x); Out> {}; 

Check , MatrixSolve , Newton , OldSolve , PrettyPrinter'Set , PSolve , Where , == .

### OldSolve -- old version of Solve

##### Calling format:
 OldSolve(eq, var) OldSolve(eqlist, varlist) 

##### Parameters:
eq -- single identity equation

var -- single variable

eqlist -- list of identity equations

varlist -- list of variables

##### Description:
This is an older version of Solve. It is retained for two reasons. The first one is philosophical: it is good to have multiple algorithms available. The second reason is more practical: the newer version cannot handle systems of equations, but OldSolve can.

This command tries to solve one or more equations. Use the first form to solve a single equation and the second one for systems of equations.

The first calling sequence solves the equation "eq" for the variable "var". Use the == operator to form the equation. The value of "var" which satisfies the equation, is returned. Note that only one solution is found and returned.

To solve a system of equations, the second form should be used. It solves the system of equations contained in the list "eqlist" for the variables appearing in the list "varlist". A list of results is returned, and each result is a list containing the values of the variables in "varlist". Again, at most a single solution is returned.

The task of solving a single equation is simply delegated to SuchThat. Multiple equations are solved recursively: firstly, an equation is sought in which one of the variables occurs exactly once; then this equation is solved with SuchThat; and finally the solution is substituted in the other equations by Eliminate decreasing the number of equations by one. This suffices for all linear equations and a large group of simple nonlinear equations.

##### Examples:
 In> OldSolve(a+x*y==z,x) Out> (z-a)/y; In> OldSolve({a*x+y==0,x+z==0},{x,y}) Out> {{-z,z*a}}; 

This means that "x = (z-a)/y" is a solution of the first equation and that "x = -z", "y = z*a" is a solution of the systems of equations in the second command.

An example which OldSolve cannot solve:

 In> OldSolve({x^2-x == y^2-y,x^2-x == y^3+y},{x,y}); Out> {}; 

Solve , SuchThat , Eliminate , PSolve , == .

### SuchThat -- special purpose solver

##### Calling format:
 SuchThat(expr, var) 

##### Parameters:
expr -- expression to make zero

var -- variable (or subexpression) to solve for

##### Description:
This functions tries to find a value of the variable "var" which makes the expression "expr" zero. It is also possible to pass a subexpression as "var", in which case SuchThat will try to solve for that subexpression.

Basically, only expressions in which "var" occurs only once are handled; in fact, SuchThat may even give wrong results if the variables occurs more than once. This is a consequence of the implementation, which repeatedly applies the inverse of the top function until the variable "var" is reached.

##### Examples:
 In> SuchThat(a+b*x, x) Out> (-a)/b; In> SuchThat(Cos(a)+Cos(b)^2, Cos(b)) Out> Cos(a)^(1/2); In> A:=Expand(a*x+b*x+c, x) Out> (a+b)*x+c; In> SuchThat(A, x) Out> (-c)/(a+b); 

Solve , OldSolve , Subst , Simplify .

### Eliminate -- substitute and simplify

##### Calling format:
 Eliminate(var, value, expr) 

##### Parameters:
var -- variable (or subexpression) to substitute

value -- new value of "var"

expr -- expression in which the substitution should take place

##### Description:
This function uses Subst to replace all instances of the variable (or subexpression) "var" in the expression "expr" with "value", calls Simplify to simplify the resulting expression, and returns the result.

##### Examples:
 In> Subst(Cos(b), c) (Sin(a)+Cos(b)^2/c) Out> Sin(a)+c^2/c; In> Eliminate(Cos(b), c, Sin(a)+Cos(b)^2/c) Out> Sin(a)+c; 

SuchThat , Subst , Simplify .

### PSolve -- solve a polynomial equation

##### Calling format:
 PSolve(poly, var) 

##### Parameters:
poly -- a polynomial in "var"

var -- a variable

##### Description:
This commands returns a list containing the roots of "poly", considered as a polynomial in the variable "var". If there is only one root, it is not returned as a one-entry list but just by itself. A double root occurs twice in the result, and similarly for roots of higher multiplicity. All polynomials of degree up to 4 are handled.

##### Examples:
 In> PSolve(b*x+a,x) Out> -a/b; In> PSolve(c*x^2+b*x+a,x) Out> {(Sqrt(b^2-4*c*a)-b)/(2*c),(-(b+ Sqrt(b^2-4*c*a)))/(2*c)}; 

Solve , Factor .

### MatrixSolve -- solve a system of equations

##### Calling format:
 MatrixSolve(A,b) 

##### Parameters:
A -- coefficient matrix

b -- row vector

##### Description:
MatrixSolve solves the matrix equations A*x = b using Gaussian Elimination with Backward substitution. If your matrix is triangular or diagonal, it will be recognized as such and a faster algorithm will be used.

##### Examples:
 In> A:={{2,4,-2,-2},{1,2,4,-3},{-3,-3,8,-2},{-1,1,6,-3}}; Out> {{2,4,-2,-2},{1,2,4,-3},{-3,-3,8,-2},{-1,1,6,-3}}; In> b:={-4,5,7,7}; Out> {-4,5,7,7}; In> MatrixSolve(A,b); Out> {1,2,3,4};