(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

Standard library
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:

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> {};

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


OldSolve -- old version of Solve

Standard library
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> {};

See also:
Solve , SuchThat , Eliminate , PSolve , == .


SuchThat -- special purpose solver

Standard library
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);

See also:
Solve , OldSolve , Subst , Simplify .


Eliminate -- substitute and simplify

Standard library
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;

See also:
SuchThat , Subst , Simplify .


PSolve -- solve a polynomial equation

Standard library
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)};

See also:
Solve , Factor .


MatrixSolve -- solve a system of equations

Standard library
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};