Use Permanent Assumptions

MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

Set Permanent Assumptions

Permanent assumptions work best for the mathematical properties that hold true throughout your computations. Suppose, you want to calculate the time during which a free-falling object drops from the height h. The kinematic equation for the free fall motion is h = gt2, where g is the free fall acceleration. Using this equation, calculate the time during which the object falls from a certain height. Without assumptions, you get the complete solution for all possible values of parameters including complex values:

t = solve(h = g*t^2/2, t)

If you do not consider the special case where no gravitational forces exist, you can safely assume that the gravitational acceleration is positive. This assumption removes the special zero-gravity cases from the solution:

assume(g > 0);
t = solve(h = g*t^2/2, t)

The variable h in the equation represents the height from which the object falls. If you do not consider that someone initially throws the object upward and that the object reflects from the ground, the height h is always positive. Therefore, you can assume that both gravitational acceleration g and height h are positive:

assume(g > 0 and h > 0);
t = solve(h = g*t^2/2, t)

Assuming that the time of the drop is a positive value, you get the expected result. When you set assumptions on variables, the solver compares the obtained solutions with the specified assumptions. This additional task can slow down the solver:

assume(g > 0 and h > 0 and t > 0);
t := solve(h = g*t^2/2, t)

The solver returns the solutions as a set, even if the set contains only one element. To access the elements of a solution set, use square brackets or the op command:

time = t[1]

Clear the variable t for further computations:

delete t

If you set several assumptions for the same object, each new assumption overwrites the previous one:

assume(h in R_);
assume(h <> 0);
is(h in R_), is(h <> 0)

If you want to keep the previous assumption while adding a new one, see Adding Assumptions.

The assume command cannot solve assumptions in the form of equations and does not assign values to the variables:

assume(g + 5 = 14.8 and 2*t = 14);
h = g*t^2/2

When you set an assumption in the form of an inequality, both sides of the inequality must represent real values. Inequalities with complex numbers are invalid because the field of complex numbers is not an ordered field. For example, if you try to use the following assumption, MuPAD® returns an error:

assume(t > 2*I)
Error: Inconsistent assumptions. [property::_assume]

You can use complex values in an assumption written in the form of an equation:

assume(t = 2*PI*I)

Add Permanent Assumptions

When you set an assumption on an object, MuPAD replaces the previous assumptions on that object with the new assumption:

assume(x in Z_);
assume(x in R_);
is(x in Z_), is(x in R_)

To add a new assumption without removing the previous assumptions, use the assumeAlso command:

assume(x in Z_);
assumeAlso(x in R_);
is(x in Z_), is(x in R_)

Also, you can set multiple assumptions in one function call by using the logical operators. For example, set two assumptions on x:

assume(x in Z_ and x in R_);
is(x in Z_), is(x in R_)

When adding assumptions, always check that a new assumption does not contradict the existing assumption. MuPAD does not guarantee to detect conflicting assumptions. For example, assume that y is simultaneously nonzero, real and an imaginary value. Type::Imaginary refers to all complex numbers lying on the imaginary axis. When you set these assumptions, MuPAD does not issue any warning and does not error:

assume(y <> 0);
assumeAlso(y in R_);
assumeAlso(y, Type::Imaginary)


Do not set conflicting assumptions because they can lead to unpredictable and inconsistent results.

To check if the assumption still holds true, use the is command. For example, MuPAD drops the assumption that the variable y represents imaginary numbers because this assumption conflicts with the combination of the previous two assumptions:

is(y <> 0), is(y in R_), is(y, Type::Imaginary)

If you set conflicting assumptions, the order in which you set them does not always determine which assumption MuPAD accepts:

assume(y <> 0);
assumeAlso(y, Type::Imaginary);
assumeAlso(y in Z_);
is(y <> 0), is(y, Type::Imaginary), is(y in Z_)

Clear Permanent Assumptions

Permanent assumptions hold for all further calculations. Before using a parameter in other calculations, check which properties MuPAD assumes to be valid for this parameter. The property::showprops command returns all assumptions specified for the parameter:

assume(g in R_);
assume(h in Z_);
assume(t > 0);

The unassume command clears a particular object from all assumptions:


To delete the value of a parameter and clear all assumptions set for this parameter, use the delete command:

delete g, h, t

For example, assign the value to the variable h and assume that h > 0:

h := g*t^2/2:
assume(g > 0 and h > 0);
property::showprops(h); h

The unassume command clears the assumption, but does not remove the value of the variable:

unassume(h > 0);
property::showprops(h); h

The delete command clears the assumption and the value:

delete h;
property::showprops(h); h