# Documentation

## Test Results

 Note:   Use only in the MuPAD Notebook Interface. This functionality does not run in MATLAB.

### Solutions Given in the Form of Equations

Suppose you want to verify the solutions of this polynomial equation:

```equation := x^3 + 4 = 0: solution := solve(equation)```

To verify the correctness of the returned solutions, substitute the solutions into the original equation. To substitute the results given in the form of equations, evaluate the original equations at the solution points. Use `evalAt` or the vertical bar `|` as a shortcut. For the first solution, the command returns the identity:

`equation | solution[1]`

To check that the left side of the equation is equal to the right side, use the `testeq` command:

`testeq(equation | solution[1])`

For the second solution, `evalAt` returns an equation with an unsimplified left side. In many cases, MuPAD® does not automatically simplify expressions, for example:

`equation | solution[2];`

`testeq` simplifies the expressions on both sides of the equation:

`testeq(equation | solution[2])`

As an alternative to evaluating at a point, use the `subs` command to substitute the solution into the original equation:

```equation := x^3 + 4 = 0: solution := solve(equation); testeq(subs(equation, solution[1])); testeq(subs(equation, solution[2])); testeq(subs(equation, solution[3]))```

To verify the solutions of a system of equations, test each equation separately:

```equations := {x^2 + 2*y = 3, 4*x^2 + 5*y = 6}: solutions := solve(equations, {x, y}); testeq((equations|solutions[1])[1]); testeq((equations|solutions[1])[2]); testeq((equations|solutions[2])[1]); testeq((equations|solutions[2])[2])```

### Solutions Given as Memberships

Suppose you want to verify the solutions of this trigonometric equation:

```equation := sin(x)/x = 0: solution := solve(equation, x)```

To verify the results, evaluate the original equation at the solution points. Evaluating at a point requires a solution to be in the form of an equation. If you have a solution in the form of membership, `evalAt` returns an error:

`equation | op(solution)`
```Error: An equation is expected. ```

You cannot use the expression `x = solution` directly because `solution` is represented by a set. This set contains the solution for the variable `x`, the independent variable `k`, and the condition on the variable `k`:

`op(solution)`

Extract the solution for `x`, the variable `k`, and the conditions on the variable `k` from the set. MuPAD returns the variable `k` and its conditions as lists. Use the additional square brackets to extract `k` and the conditions from the lists:

```op(solution)[1]; op(solution)[2][1]; op(solution)[3][1]```

Now evaluate the original equation at the solution points x = π k under the conditions for `k`:

```testeq(equation | x = op(solution)[1]) assuming op(solution)[2][1] in op(solution)[3][1]```

Alternatively, use the `subs` command to substitute the solution into the original equation:

```testeq(subs(equation, x = op(solution)[1])) assuming op(solution)[2][1] in op(solution)[3][1]```

### Solutions Obtained with `IgnoreAnalyticConstraints`

If you verify solutions of an equation or a system solved with the `IgnoreAnalyticConstraints` option, `testeq` can return `FALSE` or `UNKNOWN`, for example:

```equation := ln(x) + ln(x + 10) = ln(y): solutions := solve(equation, x, IgnoreAnalyticConstraints); testeq(subs(equation, x = solutions[1])); testeq(subs(equation, x = solutions[2]))```

When you solve an equation, inequality or a system using the `IgnoreAnalyticConstraints` option, the solver uses an additional set of simplified mathematical rules. These rules intentionally trade off mathematical strictness and correctness for simplicity of the results. Although this option often leads to the most practical and expected results, it also can lead to incorrect results. For the set of rules `IgnoreAnalyticConstraints` applies, see the help page of the `solve` command.

To verify such solutions, try using the same `IgnoreAnalyticConstraints` option for `testeq`. When you use this option, the `testeq` command does not guarantee that the solutions are correct everywhere on the complex plane. The command checks that the solutions are correct for the values of the parameters for which the rules applied by `IgnoreAnalyticConstraints` are valid:

```testeq(subs(equation, x = solutions[1]), IgnoreAnalyticConstraints); testeq(subs(equation, x = solutions[2]), IgnoreAnalyticConstraints)```

The `testeq` command did not verify both solutions. When trying to prove the equivalence of two expressions, `testeq` runs random tests before applying `IgnoreAnalyticConstraints`. If tests for random values of identifiers show that expressions are not equivalent, `testeq` disregards the `IgnoreAnalyticConstraints` option and returns `FALSE`. To suppress running random tests, set the number of these tests to zero:

```testeq(subs(equation, x = solutions[2]), NumberOfRandomTests = 0, IgnoreAnalyticConstraints)```

Verifying numeric results returned by the solver using `IgnoreAnalyticConstraints` does not require using the same option. Substitute numeric results into the original equations and call `testeq` to prove equivalence of the expressions on both sides of the equations:

```equation := x^(11/2) = 1: solution := solve(equation, IgnoreAnalyticConstraints); testeq(equation | solution[1])```