Documentation Center

  • Trial Software
  • Product Updates

Test Results

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])

Was this topic helpful?