@cortex-js/compute-engine 0.4.2 → 0.4.3

package/dist/types/compute-engine/public.d.ts

@@ -1,49 +1,648 @@
-/* 0.4.2 */
-import type { ExpressionMap } from './expression-map';
-import type { Substitution } from './patterns';
-import type { Decimal } from 'decimal.js';
+/* 0.4.3 */
 import type { Complex } from 'complex.js';
-export declare type Numeric = number | Decimal | Complex;
-export declare type Pattern<T extends number = Numeric> = Expression<T>;
-export declare type Rule<T extends number = Numeric> = [
-    lhs: string | Pattern<T>,
-    rhs: string | Pattern<T>,
-    condition?: string | ((ce: ComputeEngine<T>, args: Substitution<T>) => boolean)
+import { SignalMessage, WarningSignal, WarningSignalHandler } from '../common/signals';
+import { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
+import { NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from '../math-json';
+export declare const DEFAULT_COMPLEXITY = 100000;
+export declare const DEBUG = true;
+/**
+ * Metadata that can be associated with a BoxedExpression
+ */
+export declare type Metadata = {
+    latex?: string;
+    wikidata?: string;
+};
+/**
+ * The numeric evaluation mode:
+ *
+ * - `machine`: 64-bit float, **IEEE 754-2008**, 52-bit, about 15 digits of precision
+ * - `decimal`: arbitrary precision floating point numbers
+ * - `complex`: complex number represented by two machine numbers, a real and
+ * an imaginary part
+ * - `auto`: use machine number if precision is 15 or less, allow complex numbers.
+ */
+export declare type NumericMode = 'auto' | 'machine' | 'decimal' | 'complex';
+/** Options for `expr.simplify()` */
+export declare type SimplifyOptions = EvaluateOptions & {
+    recursive?: boolean;
+    rules?: BoxedRuleSet;
+};
+/** Options for `expr.evaluate()` */
+export declare type EvaluateOptions = {};
+/** Options for `expr.N()` */
+export declare type NOptions = {};
+export declare type ReplaceOptions = {
+    /** If true, apply replacement rules to all sub-expressions.
+     * If false, only consider the top-level expression.
+     *
+     * **Default**: true*/
+    recursive?: boolean;
+    /** If true, stop after the first rule that matches.
+     * If false, apply all the remaining rules even after the first match.
+     *
+     * **Default**: true*/
+    once?: boolean;
+    /**
+     * If `iterationLimit` > 1, the rules will be repeatedly applied
+     * until no rules apply, up to `maxIterations` times.
+     *
+     * Note that if `once` is true, `maxIterations` has no effect.
+     *
+     * **Default**: 1
+     */
+    iterationLimit?: number;
+};
+/**
+ * A substitution describes the values of the wildcards in a pattern so that
+ * the pattern is equal to a target expression.
+ *
+ * A substitution can also be considered a more constrained version of a
+ * rule whose `lhs` is always a symbol.
+ */
+export declare type Substitution = {
+    [symbol: string]: BoxedExpression;
+};
+/** A LaTeX string starts and end with `$`, for example
+ * `"$\frac{\pi}{2}$"`.
+ */
+export declare type LatexString = string;
+/**
+ *  A rule describes how to modify an expressions that matches a `lhs` pattern
+ * into a new expressions matching `rhs`.
+ *
+ * `x-1` -> `1-x`
+ * `(x+1)(x-1)` -> `x^2-1
+ *
+ * The `lhs` can be expressed as a LaTeX string or a MathJSON expression.
+ *
+ * Unbound variables (`x`, but not `Pi`) are matched structurally with a
+ * a target expression, then the expression is rewritten as the `rhs`, with
+ * the corresponding unbound variables in the `rhs` replaced by their values
+ * in the `lhs.
+ *
+ * Pattern symbols (e.g. `_1`, `_a`) can be used as well.
+ *
+ * In addition:
+ *  - `__1` (`__a`, etc..) match a sequence of one or more expressions
+ *  - `___1` (`___a`, etc...) match a sequence of zero or more expressions
+ */
+export declare type Rule = [
+    lhs: LatexString | SemiBoxedExpression | Pattern,
+    rhs: LatexString | SemiBoxedExpression,
+    options?: {
+        condition?: LatexString | ((wildcards: Substitution) => boolean);
+        priority?: number;
+    }
+];
+export declare type BoxedRule = [
+    lhs: Pattern,
+    rhs: BoxedExpression,
+    priority: number,
+    condition: undefined | ((wildcards: Substitution) => boolean)
 ];
-export declare type RuleSet<T extends number = Numeric> = Iterable<Rule<T>>;
+export declare type BoxedRuleSet = Set<BoxedRule>;
+/**
+ * Domains can be defined as a union or intersection of domains:
+ * - `["Union", "Number", "Boolean"]` A number or a boolean.
+ * - `["SetMinus", "Number", 1]`  Any number except "1".
+ *
+ */
+export declare type DomainExpression = BoxedExpression;
+export declare type JsonSerializationOptions = {
+    /** A list of space separated function names that should be excluded from
+     * the JSON output.
+     *
+     * Those functions are replaced with an equivalent, for example, `Square` with
+     * `Power`, etc...
+     *
+     * Possible values include `Sqrt`, `Root`, `Square`, `Exp`, `Subtract`,
+     * `Rational`, `Complex`
+     *
+     * **Default**: `[]` (none)
+     */
+    exclude: string[];
+    /** A list of space separated keywords indicating which MathJSON expressions
+     * can use a shorthand.
+     *
+     * **Default**: `['all']`
+     */
+    shorthands: ('all' | 'number' | 'symbol' | 'function' | 'dictionary' | 'string')[];
+    /** A list of space separated keywords indicating which metadata should be
+     * included in the MathJSON. If metadata is included, shorthand notation
+     * is not used.
+     *
+     * **Default**: `[]`
+     */
+    metadata: ('all' | 'wikidata' | 'latex')[];
+    /** If true, repeating decimals are detected and serialized accordingly
+     * For example:
+     * - `1.3333333333333333` -> `1.(3)`
+     * - `0.142857142857142857142857142857142857142857142857142` -> `0.(1428571)`
+     *
+     * **Default**: `true`
+     */
+    repeatingDecimal: boolean;
+};
 /**
- * A dictionary maps a MathJSON name to a definition.
+ * **Theory of Operations**
  *
- * A named entry in a dictionary can refer to a symbol, as in the expression,
- * `"Pi"`, to a function: "Add" in the expression `["Add", 2, 3]`, or
- * to a `"Set`".
+ * The `BoxedExpression` interface includes most of the methods applicable
+ * to any kind of expression, for example `get string()` or
+ * `get machineValue()`.
  *
- * The name can be an arbitrary string of Unicode characters, however
- * the following conventions are recommended:
+ * When they are not applicable, for example `get string()` on a
+ * `BoxedNumber`, they return `null`.
  *
- * - Use only letters, digits and `-`, and the first character should be
- * a letter: `/^[a-zA-Z][a-zA-Z0-9-]+/`
- * - Built-in functions and symbols should start with an uppercase letter
+ * This convention makes it convenient to manipulate expressions without
+ * having to check what kind of instance they are before manipulating them.
+ *
+ */
+export interface BoxedExpression {
+    /** The Compute Engine associated with this expression provides
+     * a context in which to interpret it, such as definition of symbols
+     * and functions.
+     */
+    readonly engine: IComputeEngine;
+    /** From Object.valueOf() */
+    valueOf(): number | string | [number, number];
+    /** From Object.toString() */
+    toString(): string;
+    /** From Object.toJSON(), equivalent to `JSON.stringify(this.json)` */
+    toJSON(): string;
+    /** From Object.is(). Equivalent to `isSame()` */
+    is(rhs: any): boolean;
+    get hash(): number;
+    /** A short description of the symbol or function head. May include markdown.
+     * Each string is a paragraph. */
+    readonly description: string[];
+    /** A URL pointing to more information about the symbol or function head */
+    readonly url: string;
+    /** All boxed expressions have a head.
+     *
+     * If not a function this can be `Symbol`, `String`, `Number` or `Dictionary`.
+     *
+     * If the head expression can be represented as a string, it is returned
+     * as a string.
+     */
+    get head(): BoxedExpression | string;
+    /**
+     * If `expr.isPure` is `true`, this is a synonym for `expr.evaluate()`.
+     * Otherwise, it returns `undefined`.
+     */
+    get value(): BoxedExpression | undefined;
+    /** Only the value of variables can be changed (symbols that are not constants) */
+    set value(value: BoxedExpression | undefined);
+    /** Return an approximation of the value of this expression. Floating-point
+     * operations may be performed.
+     *
+     * Just like `expr.value`, it returns `undefined` for impure expressions.
+     */
+    get numericValue(): BoxedExpression | undefined;
+    /** If true, the value of the expression never changes and evaluating it has
+     * no side-effects.
+     * If false, the value of the expression may change, if the
+     * value of other expression changes or for other reasons.
+     *
+     * If `expr.isPure` is `false`, `expr.value` is undefined. Call
+     * `expr.evaluate()` to determine the value of the expression instead.
+     *
+     * As an example, the `Random` function is not pure.
+     */
+    get isPure(): boolean;
+    /**
+     * If `true`, this expression represents a value that was not calculated
+     * or that does not reference another expression.
+     * This means the expression is either a number, a string or a dictionary.
+     * Functions and symbols are not literals.
+     */
+    get isLiteral(): boolean;
+    /** If `true`, this expression is in a canonical form */
+    get isCanonical(): boolean;
+    /** For internal use only, set when a canonical expression is created. */
+    set isCanonical(val: boolean);
+    /** `ops` is the list of arguments of the function, its "tail" */
+    get ops(): null | BoxedExpression[];
+    /** If a function, the number of operands, otherwise 0.
+     *
+     * Note that a function can have 0 operands, so to check if this expression
+     * is a function, check if `expr.tail !== null` instead. */
+    get nops(): number;
+    /** First operand, i.e. first element of `this.tail` */
+    get op1(): BoxedExpression;
+    /** Second operand, i.e. second element of `this.tail` */
+    get op2(): BoxedExpression;
+    /** Third operand, i.e. third element of `this.tail` */
+    get op3(): BoxedExpression;
+    /** The keys of the dictionary. If this expression not a dictionary, return `null` */
+    get keys(): IterableIterator<string> | null;
+    get keysCount(): number;
+    getKey(key: string): BoxedExpression | undefined;
+    hasKey(key: string): boolean;
+    /**
+     * Return the value of this number or symbol, if stored as a machine number.
+     *
+     * Note it is possible for `machineValue` to be `null`, and for `isNotZero` to be true.
+     * For example, when a symbol has been defined with an assumption.
+     *
+     * If `machineValue` is not `null`, then `decimalValue`, `rationalValue`
+     * and `complexValue` are `null.
+     *
+     */
+    get machineValue(): number | null;
+    /** If the value of this expression is a rational number, return it.
+     * Otherwise, return `[null, null]`.
+     *
+     * If `rationalValue` is not `[null, null]`, then `machineValue`, `decimalValue`
+     * and `complexValue` are `null.
+     */
+    get rationalValue(): [numer: number, denom: number] | [null, null];
+    /** If the value of this expression is a `Decimal` number, return it.
+     * Otherwise, return `null`.
+     *
+     * A `Decimal` number is an arbitrarily long floating point number.
+     *
+     * If `decimalValue` is not `null`, then `machineValue`
+     * and `complexValue` are `null` and `rationalValue` is `[null, null]`.
+     */
+    get decimalValue(): Decimal | null;
+    /** If the value of this expression is a `Complex` number, return it.
+     * Otherwise, return `null`.
+     *
+     * If `complexValue` is not `null`, then `machineValue`, `rationalValue`
+     * and `decimalValue` are `null.
+     *
+     */
+    get complexValue(): Complex | null;
+    /** Return an approximation of the numeric value of this expression as
+     * a 64-bit floating point number.
+     *
+     * If the value is a machine number, return it exactly.
+     *
+     * If the value is a rational number, return the numerator divided by the
+     * denominator.
+     *
+     * If the value is a Decimal number that can be represented by a machine
+     * number, return this value. There might be a small loss of precision due
+     * to the limitations of the binary representation of numbers as machine
+     * numbers.
+     *
+     * If the value of this expression cannot be represented by a float,
+     * return `null`.
+     *
+     */
+    get asFloat(): number | null;
+    /**
+     * If the value of this expression is an integer with a 'small' absolute value,
+     * return this value. Otherwise, return `null`.
+     *
+     * Some calculations, for example to put in canonical forms, are only
+     * performed if they are safe from overflow. This method makes it easy
+     * to check for this, whether the value is a Decimal or a number.
+     *
+     * By default, "small" is less than 10,000.
+     */
+    get asSmallInteger(): number | null;
+    /**
+     * If the value of this an expression is a small integer or a rational,
+     * return this value. Otherwise, return `[null, null`].
+     */
+    get asRational(): [number, number] | [null, null];
+    /**
+     * Return the following, depending on the value of this expression:
+     *
+     * * `-1`: if it is < 0
+     * * `0`: if it is = 0
+     * * `+1`: if it is > 0
+     * * `undefined`: this value may be positive, negative or zero. We don't know
+     *    right now (a symbol with an Integer domain, but no currently assigned
+     *    value, for example)
+     * * `null`: this value will never be positive, negative or zero (`NaN`,
+     *     a string or a complex number for example)
+     *
+     * Note that complex numbers have no natural ordering,
+     * so if the value is a complex number, `sgn` is either 0, or `null`
+     *
+     * If a symbol, this does take assumptions into account, that is `expr.sgn` will return
+     * `1` if `isPositive` is `true`, even if this expression has no value
+     */
+    get sgn(): -1 | 0 | 1 | undefined | null;
+    /** If this expression is a symbol, return the name of the symbol as a string.
+     * Otherwise, return `null`. */
+    get symbol(): string | null;
+    /**  Shortcut for `this.symbol === 'Missing'` */
+    get isMissing(): boolean;
+    /** If this expression is a string, return the value of the string.
+     * Otherwise, return `null`.
+     */
+    get string(): string | null;
+    /** True if this domain is a subset of domain d */
+    isSubsetOf(d: BoxedExpression | string): undefined | boolean;
+    /** True if the value of this expression is a number.
+     *
+     * `isExtendedComplex || isNaN` = `isReal || isImaginary || isInfinity || isNaN`
+     *
+     * Note that in a fateful twist of cosmic irony, `NaN` ("Not a Number")
+     * is a number.
+     */
+    get isNumber(): boolean | undefined;
+    /** The value of this expression is an element of the set ℤ: ...,-2, -1, 0, 1, 2... */
+    get isInteger(): boolean | undefined;
+    /** The value of this expression is an element of the set ℚ, p/q with p ∈ ℕ, q ∈ ℤ ⃰  q >= 1
+     *
+     * Note that every integer is also a rational.
+     *
+     */
+    get isRational(): boolean | undefined;
+    /**
+     * The value of this expression is a number that is the root of a non-zero
+     * univariate polynomial with rational coefficients.
+     *
+     * All integers and rational numbers are algebraic.
+     *
+     * Transcendental numbers, such as \\( \pi \\) or \\( e \\) are not algebraic.
+     *
+     */
+    get isAlgebraic(): boolean | undefined;
+    /**
+     * The value of this expression is real number: finite and not imaginary.
+     *
+     * `isFinite && !isImaginary`
+     */
+    get isReal(): boolean | undefined;
+    /** Real or ±Infinity
+     *
+     * `isReal || isInfinity`
+     */
+    get isExtendedReal(): boolean | undefined;
+    /**
+     * The value of this expression is a number, but not `NaN` or any Infinity
+     *
+     * `isReal || isImaginary`
+     *
+     */
+    get isComplex(): boolean | undefined;
+    /** `isReal || isImaginary || isInfinity` */
+    get isExtendedComplex(): boolean | undefined;
+    /** The value of this expression is a number with a imaginary part */
+    get isImaginary(): boolean | undefined;
+    get isZero(): boolean | undefined;
+    get isNotZero(): boolean | undefined;
+    get isOne(): boolean | undefined;
+    get isNegativeOne(): boolean | undefined;
+    /** ±Infinity or Complex Infinity */
+    get isInfinity(): boolean | undefined;
+    /**
+     * "Not a Number".
+     *
+     * A value representing undefined result of computations, such as `0/0`,
+     * as per the the floating point format standard IEEE-754.
+     *
+     * Note that if `isNaN` is true, `isNumber` is also true.
+     *
+     */
+    get isNaN(): boolean | undefined;
+    /** Not ±Infinity and not NaN */
+    get isFinite(): boolean | undefined;
+    get isEven(): boolean | undefined;
+    get isOdd(): boolean | undefined;
+    get isPrime(): boolean | undefined;
+    get isComposite(): boolean | undefined;
+    /** Structural/symbolic equality (weak equality).
+     *
+     * `ce.parse('1+x').isSame(ce.parse('x+1'))` is `true`
+     *
+     */
+    isSame(rhs: BoxedExpression): boolean;
+    /**
+     * True if the expression includes a symbol `v`, or a function head `v`.
+     */
+    has(v: string | string[]): boolean;
+    /** Attempt to match this pattern to the `rhs`.
+     *
+     * If `rhs` does not match, return `null`.
+     * Otherwise return an object literal, with a prop for
+     * each matching named wildcard. If `rhs` matches
+     * this pattern but there are no named wildcards, return
+     * the empty object literal, `{}`.
+     */
+    match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    /** Mathematical equality (strong equality), that is the value
+     * of this expression and of `rhs` are numerically equal.
+     *
+     * Both expressions are numerically evaluated.
+     *
+     * Numbers whose difference is less than `engine.tolerance` are
+     * considered equal. This value is set when the `engine.precision` is
+     * changed to be such that the last two digits are ignored.
+     */
+    isEqual(rhs: BoxedExpression): boolean;
+    /** If the expressions cannot be compared, `undefined` is returned */
+    isLess(rhs: BoxedExpression): boolean | undefined;
+    isLessEqual(rhs: BoxedExpression): boolean | undefined;
+    isGreater(rhs: BoxedExpression): boolean | undefined;
+    isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    /** The value of this expression is > 0, same as `isGreater(0)` */
+    get isPositive(): boolean | undefined;
+    /** The value of this expression is  >= 0, same as `isGreaterEqual(0)` */
+    get isNonNegative(): boolean | undefined;
+    /** The value of this expression is  < 0, same as `isLess(0)` */
+    get isNegative(): boolean | undefined;
+    /** The value of this expression is  <= 0, same as `isLessEqual(0)` */
+    get isNonPositive(): boolean | undefined;
+    /** Wikidata identifier */
+    get wikidata(): string;
+    set wikidata(val: string);
+    /** MathJSON representation of this expression */
+    get json(): Expression;
+    /** LaTeX representation of this expression */
+    get latex(): LatexString;
+    set latex(val: string);
+    /** Expressions with a higher complexity score are sorted
+     * first in commutative functions
+     */
+    get complexity(): number;
+    /** The domain of this expression, using the value of the expression,
+     * definitions associated with this expression and assumptions if necessary */
+    get domain(): BoxedExpression;
+    /** Symbols that represent a variable, can have their domain modified */
+    set domain(domain: BoxedExpression | string);
+    /** For symbols and functions, a possible definition associated with the expression */
+    get functionDefinition(): BoxedFunctionDefinition | undefined;
+    get symbolDefinition(): BoxedSymbolDefinition | undefined;
+    /**
+     * Return the canonical form of this expression.
+     *
+     * If a function, consider the function definition flags:
+     * - `associative`: \\( f(a, f(b), c) \longrightarrow f(a, b, c) \\)
+     * - `idempotent`: \\( f(f(a)) \longrightarrow f(a) \\)
+     * - `involution`: \\( f(f(a)) \longrightarrow a \\)
+     * - `commutative`: sort the arguments.
+     *
+     * Additionally, some simplifications involving exact computations on
+     * small integers may be performed.
+     *
+     * For example:
+     * - \\( 2 + x + 1 \longrightarrow x + 3 \\)
+     * - \\( \sqrt{4} \longrightarrow 2 \\)
+     * - \\(\frac{4}{10} \longrightarrow \frac{2}{5} \\).
+     *
+     * However, no calculation is performed involving floating point numbers, so
+     * \\( \sqrt(2) \longrightarrow \sqrt(2) \\).
+     *
+     * Determining the canonical form does not depend on the values assigned to,
+     * or assumptions about, symbols.
+     */
+    get canonical(): BoxedExpression;
+    /**
+     * Return a simpler form of this expression.
+     *
+     * The expression is first converted to canonical form. Then a series of
+     * rewriting rules are applied repeatedly, until no rules apply.
+     *
+     * If a custom `simplify` handler is associated with this function definition,
+     * it is invoked.
+     *
+     * The values assigned to symbols and the assumptions about symbols may be
+     * used, for example `arg.isInteger` or `arg.isPositive`.
+     *
+     * No calculations involving floating point numbers are performed but exact
+     * calculations may be performed, for example
+     * \\( \sin(\frac{\pi}{4}) \longrightarrow \frac{\sqrt{2}}{2} \\).
+     *
+     * The result is in canonical form.
+     *
+     */
+    simplify(options?: SimplifyOptions): BoxedExpression;
+    /**
+     * Return the value of this expression.
+     *
+     * The expression is first converted to canonical form.
+     *
+     * A pure expression always return the same value and has no side effects.
+     * If `expr.isPure` is `true`, `expr.value` and `expr.evaluate()` are synonyms.
+     * For an impure expression, `expr.value` is undefined.
+     *
+     * Evaluating an impure expression may have some side effects, for
+     * example modifying the `ComputeEngine` environment, such as its set of assumptions.
+     *
+     * Only exact calculations are performed, no floating point calculations.
+     * To perform approximate floating point calculations, use `N()` instead.
+     *
+     * The result of `expr.evaluate()` may be the same as `expr.simplify()`.
+     *
+     * The result is in canonical form.
+     *
+     */
+    evaluate(options?: EvaluateOptions): BoxedExpression;
+    /** Return a numerical approximation of this expression.
+     *
+     * The expression is first converted to canonical form.
+     *
+     * Any necessary calculations, including on floating point numbers,
+     * are performed. The calculations are performed according
+     * to the `numericMode` and `precision` properties of the `ComputeEngine`.
+     *
+     * If the function is not numeric, this is equivalent to `expr.evaluate()`.
+     *
+     * The result is in canonical form.
+     */
+    N(options?: NOptions): BoxedExpression;
+    solve(vars: Iterable<string>): null | BoxedExpression[];
+    /**
+     * If this expression is a function, apply the function `fn` to all its operands.
+     * Replace the head of this expression with `head`, if defined.
+     *
+     * If this expression is a dictionary, return a new dictionary with the values
+     * modified by `fn`.
+     *
+     * If `head` is provided, return a function
+     * with the modified dictionary as operand, otherwise return the
+     * modified dictionary. */
+    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
+    /**
+     * Transform the expression by according to the rules:
+     * the matching `lhs` of a rule is replaced by its `rhs`.
+     *
+     * If no rules apply, return `null`.
+     */
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression;
+    /**
+     * Replace all the symbols in the expression as indicated.
+     *
+     * Note the same effect can be achieved with `expr.replace()`, but
+     * this is more efficient, and simpler.
+     *
+     */
+    subs(sub: Substitution): BoxedExpression;
+    /**
+     * Update the definition associated with this expression, taking
+     * into account the current context.
+     *
+     * For internal use only.
+     */
+    _repairDefinition(): void;
+    /** Purge any cached values */
+    _purge(): undefined;
+}
+/** A semi boxed expression is an MathJSON expression which can include some
+ * boxed terms.
  *
- * As a shorthand for a numeric symbol definition, a number can be used as
- * well. In that case the domain is determined automatically.
+ * This is convenient when creating new expressions from portions
+ * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
+ */
+export declare type SemiBoxedExpression = BoxedExpression | number | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | string | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[];
+export declare type LambdaExpression = SemiBoxedExpression;
+export declare type BoxedLambdaExpression = BoxedExpression;
+export declare type PatternMatchOption = {
+    recursive?: boolean;
+    numericTolerance?: number;
+    exact?: boolean;
+};
+export interface Pattern extends BoxedExpression {
+    /**
+     * If `expr` does not match the pattern, return `null`.
+     * Otherwise, return a substitution describing the values that the named
+     * wildcard in the pattern should be changed to in order for the pattern to be
+     * equal to the expression. If there are no named wildcards and the expression
+     * matches the pattern, and empty object literal `{}` is returned.
+     */
+    match(expr: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    /** If `expr` matches the pattern, return `true`, otherwise `false` */
+    test(expr: BoxedExpression, options?: PatternMatchOption): boolean;
+    /** Return the number of exprs that matched the pattern */
+    count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOption): number;
+    subs(sub: Substitution): Pattern;
+}
+export interface ExpressionMapInterface<U> {
+    has(expr: BoxedExpression): boolean;
+    get(expr: BoxedExpression): U | undefined;
+    set(expr: BoxedExpression, value: U): void;
+    delete(expr: BoxedExpression): void;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
+}
+/**
+ * A dictionary contains definitions for symbols, functions and rules.
  *
- * ```json
- * { "x": 1.0 }
- * { "x" : { "domain": "RealNumber", "value": 1.0 } }
- * ```
  */
-export declare type Dictionary<T extends number = number> = {
-    [name: string]: T | Definition<T>;
+export declare type Dictionary = {
+    symbols?: SymbolDefinition[];
+    functions?: FunctionDefinition[];
+    simplifyRules?: BoxedRuleSet;
 };
 /**
  * The entries of a `CompiledDictionary` have been validated and
  * optimized for faster evaluation.
  *
  * When a new scope is created with `pushScope()` or when creating a new
- * engine instance, new instances of `CompiledDictionary` are created as needed.
+ * engine instance, new instances of `RuntimeDictionary` are created as needed.
  */
-export declare type CompiledDictionary<T extends number = number> = Map<string, Definition<T>>;
+export declare type RuntimeDictionary = {
+    symbols: Map<string, BoxedSymbolDefinition>;
+    symbolWikidata: Map<string, BoxedSymbolDefinition>;
+    functions: Map<string, BoxedFunctionDefinition[]>;
+    functionWikidata: Map<string, BoxedFunctionDefinition>;
+};
 /**
  * A scope is a set of names in a dictionary that are bound (defined) in
  * a MathJSON expression.
@@ -78,10 +677,10 @@ export declare type Scope = {
      * scope is exceeded. Default: no limits.*/
     iterationLimit?: number;
 };
-export declare type RuntimeScope<T extends number = number> = Scope & {
-    parentScope: RuntimeScope<T>;
-    dictionary?: CompiledDictionary<T>;
-    assumptions: undefined | ExpressionMap<T, boolean>;
+export declare type RuntimeScope = Scope & {
+    parentScope: RuntimeScope;
+    dictionary?: RuntimeDictionary;
+    assumptions: undefined | ExpressionMapInterface<boolean>;
     /** The location of the call site that created this scope */
     origin?: {
         name?: string;
@@ -93,11 +692,57 @@ export declare type RuntimeScope<T extends number = number> = Scope & {
     /** Set when one or more warnings have been signaled in this scope */
     warnings?: WarningSignal[];
 };
+export declare type BaseDefinition = {
+    /** The name of the symbol or function for this definition
+     *
+     * The name of a symbol or function is an arbitrary string of Unicode
+     * characters, however the following conventions are recommended:
+     *
+     * - Use only letters, digits and `-`, and the first character should be
+     * a letter: `/^[a-zA-Z][a-zA-Z0-9-]+/`
+     * - Built-in functions and symbols should start with an uppercase letter
+     *
+     */
+    name: string;
+    /** A short (about 1 line) description. May contain Markdown. */
+    description?: string | string[];
+    /** A URL pointing to more information about this symbol or head. */
+    url?: string;
+    /**
+     * A short string representing an entry in a wikibase.
+     *
+     * For example `Q167` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
+     * for the `Pi` constant.
+     */
+    wikidata?: string;
+    /**
+     * The domain of this item.
+     * For dictionaries, this is the domain of all the items in the dictionary
+     * For strings, it's always 'String'
+     * For symbols, this is the domain of their value.
+     * For functions, this is the domain of their result (aka codomain)
+     */
+    domain?: BoxedExpression | string;
+};
+export declare type BoxedBaseDefinition = {
+    name: string;
+    wikidata?: string;
+    description?: string | string[];
+    url?: string;
+    /**
+     * The scope this definition belongs to.
+     *
+     * This field is usually undefined, but its value is set by `getDefinition()`
+     */
+    scope: RuntimeScope | undefined;
+    domain?: BoxedExpression;
+    _purge(): undefined;
+};
 /**
- * A function definition can have some flags set indicating specific
+ * A function definition can have some flags to indicate specific
  * properties of the function.
  */
-export declare type FunctionFeatures = {
+export declare type FunctionDefinitionFlags = {
     /**  If true, the function is applied element by element to lists, matrices
      * and equations.
      *
@@ -109,7 +754,8 @@ export declare type FunctionFeatures = {
      * Default: false
      */
     associative: boolean;
-    /** If true, [f, a, b] simplifies to [f, b, a]
+    /** If true, `[f, a, b]` equals `[f, b, a]`. The canonical
+     * version of the function will order the arguments.
      *
      * Default: false
      */
@@ -120,19 +766,19 @@ export declare type FunctionFeatures = {
      * When the function is multivariate, additivity is considered only on the
      * first argument: `[f, ["Add", x, c], y]` simplifies to `["Add", [f, x, y], c]`.
      *
+     * For example, `log` is additive.
+     *
      * Default: false
      */
-    additive: boolean;
     /** If true, when the function is univariate, `[f, ["Multiply", x, y]]`
      * simplifies to `["Multiply", [f, x], [f, y]]`.
      *
-     * When the function is multivariate, multipicativity is considered only on the
+     * When the function is multivariate, multiplicativity is considered only on the
      * first argument: `[f, ["Multiply", x, y], z]` simplifies to
      * `["Multiply", [f, x, z], [f, y, z]]`
      *
      * Default: false
      */
-    multiplicative: boolean;
     /** If true, when the function is univariate, `[f, ["Multiply", x, c]]`
      * simplifies to `["Multiply", [f, x], c]` where `c` is constant
      *
@@ -142,7 +788,6 @@ export declare type FunctionFeatures = {
      *
      * Default: false
      */
-    outtative: boolean;
     /** If true, `[f, [f, x]]` simplifies to `[f, x]`.
      *
      * Default: false
@@ -154,152 +799,285 @@ export declare type FunctionFeatures = {
      */
     involution: boolean;
     /**
-     * If true, the input arguments and the result are expected to be `number`.
+     * If true, when all the arguments are numeric, the result of the
+     * evaluation is numeric. Numeric is any value with a domain of `Number`.
+     *
+     * Example of numeric functions: `Add`, `Multiply`, `Power`, `Abs`
      *
      * Default: false
      */
     numeric: boolean;
-    /** If true, invoking the function with a given set of arguments will
-     * always return the same value, i.e. `Sin` is pure, `Random` isn't.
-     * This is used to cache the result of the function.
+    /**
+     * If true, when all the arguments are boolean, the result of the
+     * evaluation is a boolean. Boolean is any value with a domain of `MaybeBoolean`.
      *
-     * Default: true
+     * Example of logic functions: `And`, `Or`, `Not`, `Implies`
+     *
+     * **Default:** false
      */
-    pure: boolean;
-};
-/** A domain such as 'Number' or 'Boolean' represents a set of values.
- *
- * Domains can be defined as a union or intersection of domains:
- * - `["Union", "Number", "Boolean"]` A number or a boolean.
- * - `["SetMinus", "Number", 1]`  Any number except "1".
- *
- * Domains are defined in a hierarchy (a lattice).
- */
-export declare type Domain<T extends number = number> = Expression<T>;
-export declare type BaseDefinition<T extends number = number> = {
-    domain: Domain<T> | ((...args: Expression<T>[]) => Domain<T>);
+    logic: boolean;
     /**
-     * A short string representing an entry in a wikibase.
+     * The function represent a relation between the first argument and
+     * the second argument, and evaluates to a boolean indicating if the relation
+     * is satisfied.
      *
-     * For example `Q167` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
-     * for the `Pi` constant.
+     * For example, `Equal`, `Less`, `Approx`, etc...
+     *
+     * **Default:** false
      */
-    wikidata?: string;
+    relationalOperator: boolean;
+    /** If true, the value of this function is always the same for a given
+     * set of arguments and it has no side effects.
+     *
+     * An expression using this function is pure if the function and all its
+     * arguments are pure.
+     *
+     * For example `Sin` is pure, `Random` isn't.
+     *
+     * This information may be used to cache the value of expressions.
+     *
+     * **Default:** true
+     */
+    pure: boolean;
     /**
-     * The scope this definition belongs to.
+     * An inert function evaluates directly to one of its argument, typically
+     * the first one. They may be used to provide formating hints, but do
+     * not affect simplification or evaluation.
      *
-     * This field is usually undefined, but its value is set by `getDefinition()`,
-     * `getFunctionDefinition()` and `getSymbolDefinition()`.
+     * **Default:** false
      */
-    scope?: Scope;
+    inert: boolean;
 };
 /**
  *
  *
  */
-export declare type FunctionDefinition<T extends number = number> = BaseDefinition<T> & Partial<FunctionFeatures> & {
+export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
+    /**
+     * A number used to order expressions. Expressions with higher
+     * complexity are placed after expressions with lower complexity when
+     * ordered canonically.
+     *
+     * Additive functions: 1000-1999
+     * Multiplicative functions: 2000-2999
+     * Root and power functions: 3000-3999
+     * Log functions: 4000-4999
+     * Trigonometric functions: 5000-5999
+     * Hypertrigonometric functions: 6000-6999
+     * Special functions (factorial, Gamma, ...): 7000-7999
+     * Collections: 8000-8999
+     * Inert and styling:  9000-9999
+     * Logic: 10000-10999
+     * Relational: 11000-11999
+     *
+     * **Default**: 100,000 (DEFAULT_COMPLEXITY)
+     */
+    complexity?: number;
     /**
-     * - `none`: Each of the arguments is evaluated
-     * - `all`: The arguments will not be evaluated and will be passed as is
+     * - `none`: Each of the arguments is evaluated (default)
+     * - `all`: None of the arguments are evaluated and they are passed as is
      * - `first`: The first argument is not evaluated, the others are
      * - `rest`: The first argument is evaluated, the others aren't
      */
-    hold?: 'none' | 'all' | 'first' | 'rest';
+    hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
     /**
-     * If true, `Sequence` arguments are not automatically spliced in
+     * If true, `Sequence` arguments appearing in the arguments of a function
+     * should not automatically be flattened out
      */
     sequenceHold?: boolean;
+    /** The minimum and maximum values of the result of the function */
+    range?: [min: number, max: number];
     /**
-     * The number and domains of the arguments for this function.
+     * Return the canonical form of the expression with the arguments `args`.
+     *
+     * All the arguments that are not subject to a hold are in canonical form.
+     * Any `Nothing` argument has been removed.
+     *
+     * If the function is associative, idempotent or an involution,
+     * it should handle its arguments accordingly. Notably, if it
+     * is commutative, the arguments should be sorted in canonical order.
+     *
+     * The handler can make transformations based on the value of the arguments
+     * that are literal and either rational numbers (i.e.
+     * `arg.isLiteral && arg.isRational`) or integers (i.e.
+     * `isLiteral && arg.isInteger`).
+     *
+     * The handler should not consider the value of the arguments
+     * that are symbols or functions.
+     *
+     * The handler should not consider any assumptions about any of the
+     * arguments that are symbols or functions i.e. `arg.isZero`,
+     * `arg.isInteger`, etc...
+     *
+     * The handler should not make transformations based on the value of
+     * floating point numbers.
+     *
+     * The result of the handler should be a canonical expression.
      *
      */
-    inputDomain?: Domain[];
+    canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
     /**
+     * Rewrite an expression into a simpler form.
      *
-     * The domain of the result.
+     * The arguments are in canonical form and have been simplified.
      *
-     * If `range` is a function, the arguments of `range()` are the
-     * the arguments of the function. The `range()` function can
-     * make use of available assumptions to determine its result.
+     * The handler can use the values assigned to symbols and the assumptions about
+     * symbols, for example with `arg.machineValue`, `arg.isInteger` or
+     * `arg.isPositive`.
      *
-     * The range should be as precise as possible. A range of
-     * `Anything` is correct, but won't be very helpful.
+     * Even though a symbol may not have a value, there may be some information
+     * about it reflected for example in `expr.isZero` or `expr.isPrime`.
      *
-     * A range of `Number` is good, a range of `RealNumber` is better
-     * and a range of `["Interval", 0, "+Infinity"]` is even better.
+     * The handler should not perform approximate numeric calculations, such
+     * as calculations involving floating point numbers. Making exact
+     * calculations on integers or rationals is OK. It is recommended, but not
+     * required, that the calculations be limited to `expr.smallIntegerValue`
+     * (i.e. numeric representations of the expression as an integer of small
+     * magnitude).
+     *
+     * This handler should not have any side-effects: do not modify
+     * the environment of the `ComputeEngine` instance, do not perform I/O,
+     * do not do calculations that depend on random values.
+     *
+     * If no simplification can be performed due to the values, domains or assumptions
+     * about its arguments, for example, return `undefined`.
      *
      */
-    range: Domain<T> | ((engine: ComputeEngine, ...args: Expression<T>[]) => Expression<T>);
+    simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
     /**
-     * The value of this function, as a lambda function.
-     * The arguments are `_`, `_2`, `_3`, etc...
+     * Evaluate symbolically an expression.
+     *
+     * The arguments have been symbolically evaluated, except the arguments to
+     * which a `hold` apply.
+     *
+     * It is not necessary to further simplify or evaluate the arguments.
+     *
+     * If the expression cannot be evaluated, due to the values, domains, or
+     * assumptions about its arguments, for example, return `undefined`.
+     *
      *
-     * This property may be used to perform some simplification, or
-     * to numerically evaluate the function if no `evalNumber` property
-     * is provided.
      */
-    value?: T | Expression;
+    evaluate?: LambdaExpression | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined);
     /**
-     * Rewrite the expression into a simplified form.
+     * Evaluate numerically `expr`.
      *
-     * If appropriate, make use of assumptions with `ce.is()`.
+     * The arguments of `expr` have been simplified and evaluated, numerically
+     * if possible, except the arguments to which a `hold` apply.
      *
-     * Do not resolve the values of variables, that is `ce.simplify("x+1")` is
-     * `x + 1` even if `x = 0`. However, resolving constants is OK.
+     * The arguments of `expr` may be a combination of numbers, symbolic
+     * expressions and other expressions.
      *
-     * Do not make approximate evaluations (i.e. floating point operations).
+     * Perform as many calculations as possible, and return the result.
      *
-     * Do not perform complex or lengthy operations: do these in `ce.evaluate()`.
+     * Return `undefined` if there isn't enough information to perform
+     * the evaluation, for example one of the arguments is a symbol with
+     * no value. If the handler returns `undefined`, symbolic evaluation of
+     * the expression will be returned instead to the caller.
      *
-     * Only make simple rewrites of the expression.
+     * Return `NaN` if there is enough information to  perform the
+     * evaluation, but a literal argument is out of range or
+     * not of the expected type.
      *
-     * The passed-in arguments have been simplified already,
-     * except for those to which a `hold` apply.
-     */
-    simplify?: (engine: ComputeEngine, ...args: Expression<T>[]) => Expression<T>;
-    /**
-     * Make a numeric evaluation of the arguments.
+     * Also return `NaN` if the result of the evaluation would be a complex
+     * number, but complex numbers are not allowed (the `engine.numericMode`
+     * is not `complex` or `auto`).
      *
-     * The passed-in arguments have already been numerically evaluated
-     * unless the arguments have a `hold` property.
+     * If the `expr.engine.numericMode` is `auto` or `complex`, you may return
+     * a Complex number as a result. Otherwise, if the result is a complex
+     * value, return `NaN`. If Complex are not allowed, none of the arguments
+     * will be complex literals.
      *
-     * If the function is `numeric` all the arguments are guaranteed to be
-     * numbers and the function should return a number.
+     * If the `expr.engine.numericMode` is `decimal` or `auto` and
+     * `expr.engine.precision` is > 15, you may return a Decimal number.
+     * Otherwise, return a `machine` number approximation. If Decimal are
+     * not allowed, none of the arguments will be Decimal literal.
+     *
+     * You may perform any necessary computations, including approximate
+     * calculations on floating point numbers.
      *
      */
-    evalNumber?: (engine: ComputeEngine, ...args: number[]) => number;
-    /** Like `evalNumber()` but for `Complex` numbers */
-    evalComplex?: (engine: ComputeEngine, ...args: (number | Complex)[]) => Complex;
-    /** Live `evalNumber()` but for Decimal numbers (arbitrary large floating
-     * point numbers).
-     */
-    evalDecimal?: (engine: ComputeEngine, ...args: (number | Decimal)[]) => Decimal;
+    N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
     /**
-     * Evaluate the arguments.
      *
-     * This will be invoked by the `ce.evaluate()` function, and
-     * after the `simplify()` and `evalNumber()` definition methods have been
-     * called.
+     * Calculate the domain of the result, based on the value of the arguments.
+     *
+     * If the domain of the result is always the same, use the `domain` property
+     * instead.
+     *
+     * The argument `args` represent the arguments of the function.
+     *
+     * The return value is `null` if the input arguments cannot be handled by
+     * this definition.
+     *
+     * Otherwise, the return value is the domain of the result.
      *
-     * If a function must perform any computations that may take a long time
-     * (>100ms), because they are computationally expensive, or because they
-     * require a network fetch, defer these computations to `ce.evaluate()`
-     * rather than `ce.simplify()`.
+     * Return `Nothing` if the arguments are acceptable, but the evaluation
+     * will fail, for example in some cases if there are missing arguments.
      *
-     * If a synchronous `ce.evaluate()` function is provided it will be used and
-     * `ce.evaluateAsync()` will not be called.
+     * This function is used to select the correct definition when there are
+     * multiple definitions for the same function name.
+     *
+     * For example it allows to distinguish between a `Add` function that
+     * applies to numbers and an `Add` function that applies to tensors.
      *
-     * The arguments have been simplified and numerically evaluated, except
-     * the arguments to which a `hold` apply.
      */
-    evaluate?: (engine: ComputeEngine, ...args: Expression<T>[]) => Expression<T>;
-    evaluateAsync?: (engine: ComputeEngine, ...args: Promise<Expression<T>>[]) => Promise<Expression<T>>;
-    /** Return a compiled (optimized) function. */
-    compile?: (engine: ComputeEngine, ...args: CompiledExpression<T>[]) => CompiledExpression<T>;
+    evalDomain?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | string | null;
     /** Dimensional analysis */
-    dimension?: (engine: ComputeEngine, ...args: Expression<T>[]) => Expression<T>;
+    evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
+    /** Return the sign of the function given a list of arguments. */
+    sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
+    /** Return a compiled (optimized) expression. */
+    compile?: (expr: BoxedExpression) => CompiledExpression;
+};
+export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
+    complexity: number;
+    hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    sequenceHold: boolean;
+    range?: [min: number, max: number];
+    canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
+    simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
+    evaluate?: BoxedLambdaExpression | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined);
+    N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
+    evalDomain?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | string | null;
+    evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
+    sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
+    compile?: (expr: BoxedExpression) => CompiledExpression;
+};
+/**
+ * When used in a `SymbolDefinition`, these flags are optional.
+ * If provided, they will override the value derived from
+ * the symbol's value.
+ *
+ * For example, it might be useful to override `algebraic = false`
+ * for a transcendental number.
+ */
+export declare type SymbolFlags = {
+    number: boolean | undefined;
+    integer: boolean | undefined;
+    rational: boolean | undefined;
+    algebraic: boolean | undefined;
+    real: boolean | undefined;
+    extendedReal: boolean | undefined;
+    complex: boolean | undefined;
+    extendedComplex: boolean | undefined;
+    imaginary: boolean | undefined;
+    positive: boolean | undefined;
+    nonPositive: boolean | undefined;
+    negative: boolean | undefined;
+    nonNegative: boolean | undefined;
+    zero: boolean | undefined;
+    notZero: boolean | undefined;
+    one: boolean | undefined;
+    negativeOne: boolean | undefined;
+    infinity: boolean | undefined;
+    NaN: boolean | undefined;
+    finite: boolean | undefined;
+    even: boolean | undefined;
+    odd: boolean | undefined;
+    prime: boolean | undefined;
+    composite: boolean | undefined;
 };
-export declare type SymbolFeatures = {
+export declare type SymbolDefinitionFlags = {
     /**
      * If true the value of the symbol is constant.
      *
@@ -307,342 +1085,206 @@ export declare type SymbolFeatures = {
      */
     constant: boolean;
     /**
-     * If false, the value of the symbol is substituted during a `ce.simplify().
-     * If true, the symbol is unchanged during a `ce.simplify()` and the value
-     * is only used during a `ce.N()` or `ce.evaluate()`.
+     * If false, the value of the symbol is substituted during canonicalization
+     * or simplification.
+     *
+     * If true, the value is only replaced during a `ce.N()` or `ce.evaluate()`.
      *
-     * True by default;
+     * **Default:** `true`
      */
-    hold?: boolean;
+    hold: boolean;
 };
-export declare type SymbolDefinition<T extends number = number> = BaseDefinition<T> & SymbolFeatures & {
-    value?: Expression<T> | ((ce: ComputeEngine) => Expression<T>);
-    /** For dimensional analysis, e.g. `Scalar`, `Meter`, `["Divide", "Meter", "Second"]` */
-    unit?: Expression<T>;
+/**
+ * A bound symbol (i.e. one with an associated definition) has either a domain
+ * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... domain = TranscendentalNumber)
+ */
+export declare type SymbolDefinition = BaseDefinition & Partial<SymbolFlags> & Partial<SymbolDefinitionFlags> & {
+    /** `value` can be a function since for some constants, such as
+     * `Pi`, the actual value depends on the `precision` setting of the
+     * `ComputeEngine` */
+    value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
+    domain?: string | BoxedExpression;
 };
-export declare type CollectionDefinition<T extends number = number> = BaseDefinition<T> & {
-    /** If true, the elements of the collection can be iterated over using
-     * the `iterator() function
-     */
-    iterable?: boolean;
-    iterator?: {
-        next: () => Expression<T>;
-        done: () => boolean;
-    };
-    /** If true, elements of the collection can be accessed with a numerical
-     * index with the `at()` function
-     */
-    indexable?: boolean;
-    at?: (index: number) => Expression<T>;
-    /** If true, the size of the collection is finite.
-     *
-     */
-    countable: boolean;
-    /** Return the number of elements in the collection.
-     */
-    size?: () => number;
-    /** A predicate function to determine if an expression
-     * is a member of the collection or not (answers `True`, `False` or `Maybe`).
-     */
-    isElementOf?: (expr: Expression<T>) => boolean;
+export interface BoxedSymbolDefinition extends BoxedBaseDefinition, Partial<SymbolFlags>, SymbolDefinitionFlags {
+    get value(): BoxedExpression | undefined;
+    set value(val: BoxedExpression | undefined);
+    at?: (index: string | number) => undefined | BoxedExpression;
+}
+export declare type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
+export declare type CompiledExpression = {
+    evaluate?: (scope: {
+        [symbol: string]: BoxedExpression;
+    }) => number | BoxedExpression;
 };
-export declare type SetDefinition<T extends number = number> = CollectionDefinition<T> & {
-    /** The supersets of this set: they should be symbol with a `Set` domain */
-    supersets: string[];
-    /** If a set can be defined explicitely in relation to other sets,
-     * the `value` represents that relationship.
-     * For example `"NaturalNumber"` = `["Union", "PrimeNumber", "CompositeNumber"]`.
+export interface ComputeEngineStats {
+    symbols: Set<BoxedExpression>;
+    expressions: null | Set<BoxedExpression>;
+    highwaterMark: number;
+}
+export interface IComputeEngine {
+    readonly ZERO: BoxedExpression;
+    readonly ONE: BoxedExpression;
+    readonly TWO: BoxedExpression;
+    readonly HALF: BoxedExpression;
+    readonly NEGATIVE_ONE: BoxedExpression;
+    readonly I: BoxedExpression;
+    readonly NAN: BoxedExpression;
+    readonly POSITIVE_INFINITY: BoxedExpression;
+    readonly NEGATIVE_INFINITY: BoxedExpression;
+    readonly COMPLEX_INFINITY: BoxedExpression;
+    readonly DECIMAL_NAN: Decimal;
+    readonly DECIMAL_ZERO: Decimal;
+    readonly DECIMAL_ONE: Decimal;
+    readonly DECIMAL_TWO: Decimal;
+    readonly DECIMAL_HALF: Decimal;
+    readonly DECIMAL_PI: Decimal;
+    readonly DECIMAL_NEGATIVE_ONE: Decimal;
+    context: RuntimeScope;
+    /** Absolute time beyond which evaluation should not proceed */
+    deadline?: number;
+    readonly timeLimit: number;
+    readonly iterationLimit: number;
+    readonly recursionLimit: number;
+    readonly defaultDomain: null | BoxedExpression;
+    numericMode: NumericMode;
+    tolerance: number;
+    chop(n: number): number;
+    chop(n: Decimal): Decimal | 0;
+    chop(n: Complex): Complex | 0;
+    chop(n: number | Decimal | Complex): number | Decimal | Complex;
+    decimal: (a: Decimal.Value) => Decimal;
+    complex: (a: number | Complex, b?: number) => Complex;
+    set precision(p: number | 'machine');
+    get precision(): number;
+    costFunction: (expr: BoxedExpression) => number;
+    /**
+     * Associate a new definition to a symbol in the current context.
+     *
+     * If a definition existed previously, it is replaced.
      */
-    value?: Expression<T>;
+    defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
+    getSymbolDefinition(name: string, wikidata?: string): undefined | BoxedSymbolDefinition;
     /**
-     * A function that determins if a set is a subset of another.
-     * The `rhs` argument is either the name of the symbol, or a function
-     * with the head of the symbol.
+     * Return `undefined` if no definition exist for this `head.
      */
-    isSubsetOf?: (engine: ComputeEngine, lhs: Expression<T>, rhs: Expression<T>) => boolean;
-};
-export declare type Definition<T extends number = number> = SymbolDefinition<T> | FunctionDefinition | SetDefinition | CollectionDefinition<T>;
-export declare type CompiledExpression<T extends number = number> = {
-    evaluate?: (scope: {
-        [symbol: string]: T | Expression<T>;
-    }) => Expression<T>;
-    asyncEvaluate?: (scope: {
-        [symbol: string]: T | Expression<T>;
-    }) => Promise<T | Expression<T>>;
-};
-export declare type Simplification = 'simplify-all' | 'simplify-arithmetic';
-export declare type NumericFormat = 'auto' | 'machine' | 'decimal' | 'complex';
-/**
- * Create a `CustomEngine` instance to customize its behavior and the syntax
- * and operation dictionaries it uses.
- *
- * The constructor of `ComputeEngine` will compile and optimize the dictionary
- * upfront.
- */
-export declare class ComputeEngine<T extends number = Numeric> {
+    getFunctionDefinition(head: string, wikidata?: string): undefined | BoxedFunctionDefinition;
     /**
-     * Return dictionaries suitable for the specified categories, or `"all"`
-     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
+     * Returned a boxed expression from the input.
      *
-     * A symbol dictionary defines how the symbols and function names in a MathJSON
-     * expression should be interpreted, i.e. how to evaluate and manipulate them.
+     * The result may not be canonical.
+     */
+    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression): BoxedExpression;
+    /** Return a canonical boxed number */
+    number(value: number | MathJsonNumber | Decimal | Complex | [num: number, denom: number], metadata?: Metadata): BoxedExpression;
+    /** Return a canonical boxed symbol */
+    symbol(sym: string, metadata?: Metadata): BoxedExpression;
+    /** Return a canonical boxed string */
+    string(s: string, metadata?: Metadata): BoxedExpression;
+    /** Return a canonical boxed domain */
+    domain(domain: BoxedExpression | string, metadata?: Metadata): BoxedExpression;
+    /** Return a canonical expression.
+     *
+     * Note that the result may not be a function, or may have a different
+     * `head` than the one specified.
+     *
+     * For example `ce.fn('Add', [ce.number(2),  ce.number(3)]))` -> 5
      *
      */
-    static getDictionaries(categories: DictionaryCategory[] | 'all'): Readonly<Dictionary<any>>[];
+    fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
     /**
-     * The current scope.
+     * This is a primitive to create a boxed function. It doesn't perform
+     * any checks or normalization on its arguments.
      *
-     * A scope is a dictionary that contains the definition of local symbols.
-     *
-     * Scopes form a stack, and definitions in more recent
-     * scopes can obscure definitions from older scopes.
+     * In general, consider using `fn()` or `box()` instead.
      *
+     * The result is canonical, but the caller has to ensure that all the
+     * conditions are met (i.e. ops properly normalized and sorted, all
+     * ops canonical, etc..) so that the result is actually canonical.
      */
-    context: RuntimeScope<T>;
-    readonly assumptions: ExpressionMap<T, boolean>;
-    /** Absolute time beyond which evaluation should not proceed */
-    deadline?: number;
-    readonly timeLimit?: number;
-    readonly iterationLimit?: number;
-    readonly recursionLimit?: number;
-    /** The default precision of the compute engine: the number of significant
-     * digits when performing numeric evaluations, such as when calling `ce.N()`.
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Error'...)`.
      *
-     * To make calculations using machine floating point representation, set
-     * `precision` to `"machine"`  (15 by default).
+     * The result is canonical.
+     */
+    error(val: BoxedExpression, message: string, messageArg: SemiBoxedExpression): any;
+    /** Shortcut for `fn('Add'...)`.
      *
-     * To  make calculations using more digits, at the cost of expended memory
-     * usage and slower computations, set the `precision` higher.
+     * The result is canonical.
+     */
+    add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Multiply'...)`
      *
-     * Trigonometric operations are accurate for precision up to 1,000.
+     * The result is canonical.
+     */
+    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Power'...)`
      *
-     * Some functions, such as `ce.N()` have an option to specify the precision.
-     * If no precision is specified in these functions, the precision of
-     * the compute engine is used.
+     * The result is canonical.
+     */
+    power(base: BoxedExpression, exponent: number | [number, number] | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Divide', 1, expr)`
      *
+     * The result is canonical.
      */
-    set precision(p: number | 'machine');
-    get precision(): number;
-    /**
-     * Internal format to represent numbers:
-     * - `auto`: the best format is determined based on the calculations to perform
-     * and the requested precision.
-     * - `number`: use the machine format (64-bit float, 52-bit, about 15 digits
-     * of precision).
-     * - `decimal`: arbitrary precision floating-point numbers, as provided by the
-     * "decimal.js" library
-     * - `complex`: complex numbers: two 64-bit float, as provided by the
-     * "complex.js" library
+    inverse(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Negate'...)`
      *
+     * The result is canonical.
      */
-    numericFormat: NumericFormat;
-    /**
-     * Values smaller than the tolerance are considered to be zero for the
-     * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
-     * equal to `a`.
+    negate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Divide'...)`
+     *
+     * The result is canonical.
      */
-    tolerance: number;
-    /**
-     * Construct a new `ComputeEngine` environment.
+    divide(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Pair'...)`
      *
-     * If no `options.dictionaries` is provided a default set of dictionaries
-     * is used. The `ComputeEngine.getDictionaries()` method can be called
-     * to access some subset of dictionaries, e.g. for arithmetic, calculus, etc...
-     * The order of the dictionaries matter: the definitions from the later ones
-     * override the definitions from earlier ones. The first dictionary should
-     * be the `'core'` dictionary which include some basic definitions such
-     * as domains (`Boolean`, `Number`, etc...) that are used by later dictionaries.
+     * The result is canonical.
      */
-    constructor(options?: {
-        dictionaries?: Readonly<Dictionary<T>>[];
-    });
-    /** Create a new scope and add it to the top of the scope stack */
-    pushScope(dictionary: Readonly<Dictionary<T>>, scope?: Partial<Scope>): void;
-    /** Remove the topmost scope from the scope stack.
+    pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `fn('Tuple'...)`
+     *
+     * The result is canonical.
      */
-    popScope(): void;
+    tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    rules(rules: Rule[]): BoxedRuleSet;
+    pattern(expr: LatexString | SemiBoxedExpression): Pattern;
     /**
-     * Call this function if an unexpected condition occurs during execution of a
-     * function in the engine.
-     *
-     * An `ErrorSignal` is a problem that cannot be recovered from.
+     * Parse a string of LaTeX and return a corresponding `BoxedExpression`.
      *
-     * A `WarningSignal` indicates a minor problem that does not prevent the
-     * execution to continue.
+     * The result may not be canonical.
      *
      */
-    signal(sig: ErrorSignal | WarningSignal): void;
-    /**
-     * Return false if the execution should stop.
-     *
-     * This can occur if:
-     * - an error has been signaled
-     * - the time limit or memory limit has been exceeded
+    parse(s: null | string | LatexString): BoxedExpression | null;
+    /** Serialize a `BoxedExpression` or a `MathJSON` expression to
+     * a LaTeX string
      */
+    serialize(expr: SemiBoxedExpression): LatexString;
+    get latexOptions(): Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
+    set latexOptions(opts: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions);
+    get jsonSerializationOptions(): JsonSerializationOptions;
+    set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
+    assume(symbol: LatexString | SemiBoxedExpression, domain: BoxedExpression): AssumeResult;
+    assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
+    assume(arg1: LatexString | SemiBoxedExpression, arg2?: BoxedExpression): AssumeResult;
+    forget(symbol?: string | string[]): void;
+    get assumptions(): ExpressionMapInterface<boolean>;
+    ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
+    pushScope(options?: {
+        dictionary?: Readonly<Dictionary> | Readonly<Dictionary>[];
+        assumptions?: (LatexString | Expression | BoxedExpression)[];
+        scope?: Partial<Scope>;
+    }): void;
+    popScope(): void;
+    assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): any;
+    signal(expr: BoxedExpression, msg: string, code?: SignalMessage): void;
+    signal(sig: WarningSignal): void;
     shouldContinueExecution(): boolean;
     checkContinueExecution(): void;
-    getFunctionDefinition(name: string): FunctionDefinition | null;
-    getSymbolDefinition(name: string): SymbolDefinition<T> | null;
-    getSetDefinition(name: string): SetDefinition | null;
-    getCollectionDefinition(name: string): CollectionDefinition<T> | null;
-    getDefinition(name: string): Definition<T> | null;
-    /** Format the expression to the canonical form.
-     *
-     * In the canonical form, some operations are simplified (subtractions
-     * becomes additions of negative, division become multiplications of inverse,
-     * etc...) and terms are ordered using a deglex order. This can make
-     * subsequent operations easier.
-     */
-    canonical(expr: Expression<T> | null): Expression<T> | null;
-    /** Format the expression according to the specified forms.
-     *
-     * If no form is provided, the expression is formatted with the 'canonical'
-     * form.
-     *
-     */
-    format(expr: Expression<T> | null, forms?: Form | Form[]): Expression<T> | null;
-    /**
-     * Evaluate the expression `exp` asynchronously.
-     *
-     * Evaluating some expressions can take a very long time. Some can invole
-     * making network queries. Therefore to avoid blocking the main event loop,
-     * a promise is returned.
-     *
-     * Use `result = await engine.evaluate(expr)` to get the result without
-     * blocking.
-     */
-    evaluate(expr: Expression<T>, options?: {
-        timeLimit?: number;
-        iterationLimit?: number;
-    }): Promise<Expression<T> | null>;
-    /**
-     * Simplify an expression.
-     */
-    simplify(exp: Expression<T>, options?: {
-        timeLimit?: number;
-        iterationLimit?: number;
-        simplifications?: Simplification[];
-    }): Expression<T> | null;
-    /**
-     * Return a numerical approximation of an expression.
-     */
-    N(exp: Expression<T>, options?: {
-        precision?: number;
-    }): T | Expression<T> | null;
-    /**
-     * Determines if the predicate is satisfied based on the known assumptions.
-     *
-     * Return `undefined` if the value of the predicate cannot be determined.
-     *
-     * ```js
-     * ce.is(["Equal", "x", 0]);
-     * ce.is(["Equal", 3, 4]);
-     * ```
-     *
-     */
-    is(symbol: Expression<T>, domain: Domain): boolean | undefined;
-    is(predicate: Expression<T>): boolean | undefined;
-    is(arg1: Expression<T>, arg2?: Domain): boolean | undefined;
-    /**
-     * Return a list of all the assumptions that match a pattern.
-     *
-     * ```js
-     *  ce.assume(x, 'PositiveInteger');
-     *  ce.ask(['Greater', 'x', '_val'])
-     *  //  -> [{'val': 0}]
-     * ```
-     */
-    ask(pattern: Expression<T>): Substitution<T>[];
-    /**
-     * Apply repeatedly a set of rules to an expression.
-     */
-    replace(rules: RuleSet<T>, expr: Expression<T>): Expression<T>;
-    /**
-     * Add an assumption.
-     *
-     * Return `contradiction` if the new assumption is incompatible with previous
-     * ones.
-     *
-     * Return `tautology` if the new assumption is redundant with previous ones.
-     *
-     * Return `ok` if the assumption was successfully added to the assumption set.
-     *
-     * Note that the assumption is put into normal form before being added.
-     *
-     */
-    assume(symbol: Expression<T>, domain: Domain): 'contradiction' | 'tautology' | 'ok';
-    assume(predicate: Expression<T>): 'contradiction' | 'tautology' | 'ok';
-    assume(arg1: Expression<T>, arg2?: Domain): 'contradiction' | 'tautology' | 'ok';
-    parse(s: string): Expression<T>;
-    serialize(x: Expression<T>): string;
-    getRules(topic: string | string[]): RuleSet;
-    /** Return the domain of the expression */
-    domain(expr: Expression<T>): Expression<T> | null;
-    /** Return the variables in the expression */
-    getVars(expr: Expression<T>): Set<string>;
-    chop(n: Numeric): Numeric;
-    isZero(x: Expression<T>): boolean | undefined;
-    isNotZero(x: Expression<T>): boolean | undefined;
-    isNumeric(x: Expression<T>): boolean | undefined;
-    isInfinity(x: Expression<T>): boolean | undefined;
-    isFinite(x: Expression<T>): boolean | undefined;
-    isNonNegative(x: Expression<T>): boolean | undefined;
-    isPositive(x: Expression<T>): boolean | undefined;
-    isNegative(x: Expression<T>): boolean | undefined;
-    isNonPositive(x: Expression<T>): boolean | undefined;
-    isInteger(x: Expression<T>): boolean | undefined;
-    isRational(x: Expression<T>): boolean | undefined;
-    isAlgebraic(x: Expression<T>): boolean | undefined;
-    isReal(x: Expression<T>): boolean | undefined;
-    isExtendedReal(x: Expression<T>): boolean | undefined;
-    isComplex(x: Expression<T>): boolean | undefined;
-    isOne(x: Expression<T>): boolean | undefined;
-    isNegativeOne(x: Expression<T>): boolean | undefined;
-    isElement(x: Expression<T>, set: Expression<T>): boolean | undefined;
-    isSubsetOf(lhs: Domain | null, rhs: Domain | null): boolean;
-    isEqual(lhs: Expression<T>, rhs: Expression<T>): boolean | undefined;
-    isLess(lhs: Expression<T>, rhs: Expression<T>): boolean | undefined;
-    isLessEqual(lhs: Expression<T>, rhs: Expression<T>): boolean | undefined;
-    isGreater(lhs: Expression<T>, rhs: Expression<T>): boolean | undefined;
-    isGreaterEqual(lhs: Expression<T>, rhs: Expression<T>): boolean | undefined;
+    cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
+    readonly stats: ComputeEngineStats;
+    purge(): void;
+    _register(expr: BoxedExpression): void;
+    _unregister(expr: BoxedExpression): void;
 }
-/**
- * Transform an expression by applying one or more rewriting rules to it,
- * recursively.
- *
- * There are many ways to symbolically manipulate an expression, but
- * transformations with `form` have the following characteristics:
- *
- * - they don't require calculations or assumptions about the domain of free
- *    variables or the value of constants
- * - the output expression is expressed with more primitive functions,
- *    for example subtraction is replaced with addition
- *
- *
- */
-export declare function format<T extends number = number>(expr: Expression<T>, forms: Form[], options?: {
-    dictionaries?: Readonly<Dictionary<T>>[];
-}): Expression<T>;
-/**
- * Apply the definitions in the supplied dictionary to an expression
- * and return the result.
- *
- * Unlike `format` this may entail performing calculations and irreversible
- * transformations.
- *
- * See also `[ComputeEngine.evaluate()](#(ComputeEngine%3Aclass).(evaluate%3Ainstance))`.
- *
- * @param dictionaries - An optional set of functions and constants to use
- * when evaluating the expression. Evaluating the expression may modify the
- * scope, for example if the expression is an assignment or definition.
- */
-export declare function evaluate<T extends number = number>(expr: Expression<T>, options?: {
-    dictionaries?: Readonly<Dictionary<T>>[];
-}): Promise<Expression<T> | null>;
-/**
- * A given mathematical expression can be represented in multiple equivalent
- * ways as a MathJSON expression.
- *
- * Learn more about [Canonical Forms](https://cortexjs.io/guides/compute-engine/forms/).
- */
-export declare type Form = 'canonical' | 'canonical-add' | 'canonical-boolean' | 'canonical-constants' | 'canonical-divide' | 'canonical-domain' | 'canonical-exp' | 'canonical-list' | 'canonical-multiply' | 'canonical-power' | 'canonical-negate' | 'canonical-number' | 'canonical-rational' | 'canonical-root' | 'canonical-subtract' | 'canonical-domain' | 'flatten' | 'json' | 'object-literal' | 'sorted' | 'stripped-metadata' | 'sum-product';
+export declare function getVars(expr: BoxedExpression): string[];