Assumptions

Assumptions are statements about symbols that are assumed to be true. For example, the assumption that \(x\) is a positive real number is used to simplify \|x|\) to \(x\).

When declaring a symbol, it is possible to specify its domain. For example, the symbol \(x\) can be declared to be a real number:

ce.declare("x", "RealNumbers");

However, assumptions can be used to describe more complex properties of symbols. For example, the assumption that \(x\) is positive is used to simplify \(\sqrt{x^2}\) to \(x\).

ce.assume(["Greater", "x", 2]);

Assumptions can also describe the relationship between two symbols, for example that \(x\) is greater than \(y\):

ce.assume(["Greater", "x", "y"]);

This knowledge base is used by the Compute Engine to simplify expressions.

In general, assumptions are not used when evaluating expressions.

Defining New Assumptions

To make an assumption about a symbol, use the ce.assume() function.

For example, to indicate \(\beta \in \R\):

ce.assume(ce.parse("\\beta \\in \\R"));

// or:

ce.assume(["Element", "Beta", "RealNumbers"]);

In this case, this would be equivalent to declaring a domain for the symbol \(\beta\):

ce.declare("Beta", "RealNumbers");

The head of the proposition can be one of the following:

Head
`Element` `NotElement`	Indicate the domain of a symbol
`Less` `LessEqual` `Greater` `GreaterEqual`	Inequality. Both sides are assumed to be `RealNumbers`
`Equal` `NotEqual`	Equality
`And` `Or` `Not`	Boolean expression. Using `And` is equivalent to using multiple `assume()` for each term of the boolean expression.

If the assume() function is invoked with two arguments, it is equivalent to ce.assume(["Element", <arg1>, <arg2>]).

ce.assume(["Element", "x", "RealNumbers"); // same as ce.assume(["Element", "x", "RealNumbers"])

The argument to the assume() function is a proposition. That proposition is analyzed and the fact it describes are recorded in the Compute Engine assumptions knowledge base. Some propositions can be described in several different but equivalent ways. You can use whichever form you prefer. Similarly, when querying the knowledge base later, you can use any form you’d like.

ce.assume(["Element", "x", "PositiveNumbers"]);
 
// Equivalent to...
ce.assume(["Greater", "x", 0]);
 
// ... or ...
ce.assume(["Element", "x", ["Interval", ["Open", 0], "Infinity"]]);

Multivariate Assumptions

Assumptions frequently describe the property of a symbol. However, it is also possible to describe relationships betwen symbols.

ce.assume(ce.parse('xy + 1 = 0'))'

Default Assumptions

When creating an instance of a Compute Engine, the following assumptions are made:

Symbol	Domain
`a` `b` `c` `d` `i` `j` `k` `r` `t` `x` `y`	`RealNumbers`
`f` `g` `h`	`Functions`
`m` `n` `p` `q`	`Integers`
`w` `z`	`ComplexNumbers`

This list of assumptions make it possible to immediately use common symbols such as x or y without having to declare them explicitly.

To specify a different list of assumptions, use the assumptions option when creating a Compute Engine instance:

const ce = new ComputeEngine({
  assumptions: [
    ["Element", "x", "Integers"],
    ["Element", "y", "Integers"],
  ],
});

To have no assumptions at all, set the assumptions option to null:

const ce = new ComputeEngine({ assumptions: null });

Verifyinf Assumptions

To test if a particular assumption is valid, call the ce.verify() function.

ce.verify(["Element", "x", "RealNumbers"]);

The function ce.verify() return true if the assumption is true, false if it is not, and undefined if it cannot be determined.

While ce.verify() is appropriate to get boolean answers, more complex queries can also be made.

To query the assumptions knowledge base call the ce.ask() function.

The argument of ask() can be a pattern, and it returns an array of matches as Substitution objects.

// "x is a positive integer"
ce.assume(["Element", "x", "PositiveIntegers"]);

// "What is x greater than?"
ce.ask(["Greater", "x", "_val"]);

//  -> [{"val": 0}] "It is greater than 0"

Forgetting Assumptions

Each call to ce.assume() is additive: the previous assumptions are preserved.

To remove previous assumptions, use ce.forget().

Calling ce.forget() with no arguments will remove all assumptions.
Passing an array of symbol names will remove assumptions about each of the symbols.
Passing a symbol name will only remove assumptions about that particular symbol.

ce.assume(["Element", "\\alpha", "RealNumbers"]);
ce.is(["Element", "\\alpha", "RealNumbers"]);
// ➔  true

ce.forget("\\alpha");

ce.is(["Element", "\\alpha", "RealNumbers"]);
// ➔  undefined

Scoped Assumptions

When an assumption is made, it is applicable to the current scope and all subsequent scopes. Scopes “inherit” assumptions from their parent scopes.

When exiting a scope, with ce.popScope(), all assumptions made in that scope are forgotten.

To temporarily define a series of assumptions, create a new scope.

ce.is(["Element", "\\alpha", "RealNumbers"]);
// ➔ undefined

ce.pushScope();

ce.assume(["Element", "\\alpha", "RealNumbers"]);
ce.is(["Element", "\\alpha", "RealNumbers"]);
// ➔  true

ce.popScope(); // all assumptions made in the current scope are forgotten

ce.is(["Element", "\\alpha", "RealNumbers"]);
// ➔  undefined