@cortex-js/compute-engine 0.6.0 → 0.8.0

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -17,18 +17,18 @@ export * from './latex-syntax/public';
  * Metadata that can be associated with a `BoxedExpression`
  */
 export declare type Metadata = {
-    latex?: string;
-    wikidata?: string;
+    latex?: string | undefined;
+    wikidata?: string | undefined;
 };
 /**
  * The numeric evaluation mode:
  *
- * - `auto`: use machine number if precision is 15 or less, allow complex numbers.
- * - `machine`: 64-bit float, **IEEE 754-2008**, 64-bit float, 52-bit mantissa,
+ * - `"auto"`: use machine number if precision is 15 or less, allow complex numbers.
+ * - `"machine"`: 64-bit float, **IEEE 754-2008**, 64-bit float, 52-bit mantissa,
  *    about 15 digits of precision
- * - `decimal`: arbitrary precision floating point numbers, as provided by the
+ * - `"decimal"`: arbitrary precision floating point numbers, as provided by the
  * "decimal.js" library
- * - `complex`: complex number represented by two machine numbers, a real and
+ * - `"complex"`: complex number represented by two machine numbers, a real and
  * an imaginary part, as provided by the "complex.js" library
  */
 export declare type NumericMode = 'auto' | 'machine' | 'decimal' | 'complex';
@@ -49,16 +49,16 @@ export declare type EvaluateOptions = {};
  */
 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.
+    /** 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 `true`, stop after the first rule that matches.
      *
-     * If false, apply all the remaining rules even after the first match.
+     * If `false`, apply all the remaining rules even after the first match.
      *
      * **Default**: `true`
      */
@@ -81,6 +81,9 @@ export declare type ReplaceOptions = {
  * rule whose `lhs` is always a symbol.
  */
 export declare type Substitution = {
+    [symbol: string]: SemiBoxedExpression;
+};
+export declare type BoxedSubstitution = {
     [symbol: string]: BoxedExpression;
 };
 /** A LaTeX string starts and end with `$`, for example
@@ -111,7 +114,7 @@ export declare type Rule = [
     lhs: LatexString | SemiBoxedExpression | Pattern,
     rhs: LatexString | SemiBoxedExpression,
     options?: {
-        condition?: LatexString | ((wildcards: Substitution) => boolean);
+        condition?: LatexString | ((wildcards: BoxedSubstitution) => boolean);
         priority?: number;
     }
 ];
@@ -119,51 +122,44 @@ export declare type BoxedRule = [
     lhs: Pattern,
     rhs: BoxedExpression,
     priority: number,
-    condition: undefined | ((wildcards: Substitution) => boolean)
+    condition: undefined | ((wildcards: BoxedSubstitution) => boolean)
 ];
 export declare type BoxedRuleSet = Set<BoxedRule>;
-export declare type ParametricDomainFunction = 'Function' | 'Union' | 'List' | 'Record' | 'Tuple' | 'Intersection' | 'Range' | 'Interval' | 'Optional' | 'Some' | 'Head' | 'Symbol' | 'Literal';
-export declare type ParametricDomain = [
-    ParametricDomainFunction,
-    ...DomainExpression[]
-];
-export declare type DomainExpression = string | ParametricDomain;
-/**
- * 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 interface Domain extends BoxedExpression {
-    isSubdomainOf(dom: Domain | string): boolean;
-    isMemberOf(expr: BoxedExpression): boolean;
-    readonly domainExpression: DomainExpression;
-    codomain: Domain | null;
+export declare type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
+/** A domain constructor is the head of a domain expression. */
+export declare type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
+export declare type DomainLiteral = string;
+export declare type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
+export interface BoxedDomain extends BoxedExpression {
+    is(s: BoxedDomain): boolean;
+    /** True if a valid domain, and compatible with `dom` */
+    isCompatible(dom: BoxedDomain | DomainLiteral, kind?: DomainCompatibility): boolean;
+    get literal(): string | null;
+    get ctor(): DomainConstructor | null;
+    get domainArgs(): (DomainExpression<BoxedExpression> | BoxedExpression | string)[] | null;
+    get domainArg1(): string | BoxedExpression | DomainExpression<BoxedExpression> | null;
+    get codomain(): BoxedDomain | null;
+    get canonical(): BoxedDomain;
+    get json(): Expression;
     readonly isNothing: boolean;
-    is(s: BoxedExpression): boolean;
-    readonly isBoolean: boolean;
     readonly isNumeric: boolean;
     readonly isFunction: boolean;
-    readonly isPredicate: boolean;
     /**
      * 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
+     * Default: `false`
      */
-    readonly isNumericFunction: boolean;
-    readonly isRealFunction: boolean;
     /**
      * 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`.
      *
      * Example of logic functions: `And`, `Or`, `Not`, `Implies`
      *
-     * **Default:** false
+     * **Default:** `false`
      */
-    readonly isLogicOperator: boolean;
     /**
      * The function represent a relation between the first argument and
      * the second argument, and evaluates to a boolean indicating if the relation
@@ -171,7 +167,7 @@ export interface Domain extends BoxedExpression {
      *
      * For example, `Equal`, `Less`, `Approx`, etc...
      *
-     * **Default:** false
+     * **Default:** `false`
      */
     readonly isRelationalOperator: boolean;
 }
@@ -194,7 +190,7 @@ export declare type JsonSerializationOptions = {
     /** A list of space separated keywords indicating which MathJSON expressions
      * can use a shorthand.
      *
-     * **Default**: `['all']`
+     * **Default**: `["all"]`
      */
     shorthands: ('all' | 'number' | 'symbol' | 'function' | 'dictionary' | 'string')[];
     /** A list of space separated keywords indicating which metadata should be
@@ -235,542 +231,638 @@ export interface BoxedExpression {
     readonly engine: IComputeEngine;
     /** From `Object.valueOf()`, return a primitive value for the expression.
      *
-     * If the expression is a machine number, or a Decimal that can be
+     * If the expression is a machine number, or a Decimal or rational that can be
      * converted to a machine number, return a `number`.
      *
-     * If the expression is a rational number, return `[number, number]`.
-     *
      * If the expression is a symbol, return the name of the symbol as a `string`.
      *
      * Otherwise return a LaTeX representation of the expression.
      *
-     * @category Object Methods
+     * @category Primitive Methods
      */
-    valueOf(): number | string | [number, number];
+    valueOf(): number | string | boolean;
     /** From `Object.toString()`, return a LaTeX representation of the expression.
      *
-     * @category Object Methods
+     * Used when coercing a `BoxedExpression` to a `String`.
+     *
+     * @category Primitive Methods
      */
     toString(): string;
-    /** From `Object.toJSON()`, equivalent to `JSON.stringify(this.json)`
+    /** Similar to`expr.valueOf()` but includes a hint.
+     * @category Primitive Methods
+     */
+    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
+    /** Used by `JSON.stringify()` to serialize this object to JSON.
+     *
+     * Method version of `expr.json`.
+     *
+     * @category Primitive Methods
+     */
+    toJSON(): Expression;
+    /** If `true`, this expression is in a canonical form.
+     *
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     * @category Object Methods
      */
-    toJSON(): string;
+    get isCanonical(): boolean;
+    /** For internal use only, set when a canonical expression is created.
+     * @internal
+     */
+    set isCanonical(val: boolean);
+    /** MathJSON representation of this expression.
+     *
+     * **Note** applicable to canonical and non-canonical expressions.
+     *
+     */
+    readonly json: Expression;
     /** From `Object.is()`. Equivalent to `BoxedExpression.isSame()`
      *
-     * @category Object Methods
+     * @category Primitive Methods
      *
      */
     is(rhs: unknown): boolean;
     /** @internal */
-    get hash(): number;
-    /** An optional short description of the symbol or function head.
+    readonly hash: number;
+    /** LaTeX representation of this expression.
      *
-     * May include markdown. Each string is a paragraph. */
-    readonly description: string[];
-    /** An optional URL pointing to more information about the symbol or function head */
-    readonly url: string;
-    /** All boxed expressions have a head.
+     * The serialization can be customized with `ComputeEngine.latexOptions`
      *
-     * If not a function this can be `Symbol`, `String`, `Number` or `Dictionary`.
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     * If the head expression can be represented as a string, it is returned
-     * as a string.
      */
-    get head(): BoxedExpression | string;
+    get latex(): LatexString;
     /**
-     * If `this.isPure` is `true`, this is a synonym for `this.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 | number | undefined);
-    /** Return an approximation of the value of this expression. Floating-point
-     * operations may be performed.
      *
-     * Just like `this.value`, it returns `undefined` for impure expressions.
+     * **Note** applicable to canonical and non-canonical expressions.
+     * @internal
      */
-    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.
+    set latex(val: string);
+    /** If this expression is a symbol, return the name of the symbol as a string.
+     * Otherwise, return `null`.
      *
-     * If `this.isPure` is `false`, `this.value` is undefined. Call
-     * `this.evaluate()` to determine the value of the expression instead.
+     * **Note** applicable to canonical and non-canonical expressions.
+  
+    * @category Symbol Expression
      *
-     * As an example, the `Random` function is not pure.
      */
-    get isPure(): boolean;
+    readonly symbol: string | null;
     /**
-     * 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.
-     * @internal
+     * If this is the `Nothing` symbol, return `true`.
+     *
+     * **Note** applicable to canonical and non-canonical expressions.
      */
-    set isCanonical(val: boolean);
-    /** `ops` is the list of arguments of the function, its "tail"
+    readonly isNothing: boolean;
+    /** If this expression is a string, return the value of the string.
+     * Otherwise, return `null`.
      *
-     * @category Function Expression
+     * **Note** applicable to canonical and non-canonical expressions.
+  
+    * @category String Expression
      *
      */
-    get ops(): null | BoxedExpression[];
-    /** If this expression is 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 `this.ops !== null` instead.
+    readonly string: string | null;
+    /** All the subexpressions matching the head
      *
-     * @category Function Expression
+     * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    get nops(): number;
-    /** First operand, i.e.`this.ops[0]`
+    getSubexpressions(head: string): BoxedExpression[];
+    /** All the subexpressions in this expression, recursively
      *
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     * @category Function Expression
+     */
+    readonly subexpressions: BoxedExpression[];
+    /** All the symbols in the expression, recursively
      *
+     * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    get op1(): BoxedExpression;
-    /** Second operand, i.e.`this.ops[0]`
+    readonly symbols: BoxedExpression[];
+    /** All the `["Error"]` subexpressions
      *
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     * @category Function Expression
+     */
+    readonly errors: BoxedExpression[];
+    /** 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.
      *
+     * **Note** applicable to canonical and non-canonical expressions. The head
+     * of a non-canonical expression may be different than the head of its
+     * canonical counterpart. For example the canonical counterpart of `["Divide", 5, 7]` is `["Rational", 5, 5]`.
      */
-    get op2(): BoxedExpression;
-    /** Third operand, i.e. `this.ops[2]`
+    readonly head: BoxedExpression | string;
+    /** The list of arguments of the function, its "tail".
      *
+     * If the expression is not a function, return `null`.
      *
-     * @category Function Expression
+     * **Note** applicable to canonical and non-canonical expressions.
      *
+     * @category Function Expression
      *
      */
-    get op3(): BoxedExpression;
-    /** The keys of the dictionary.
+    readonly ops: null | BoxedExpression[];
+    /** If this expression is a function, the number of operands, otherwise 0.
      *
-     * If this expression not a dictionary, return `null`
+     * Note that a function can have 0 operands, so to check if this expression
+     * is a function, check if `this.ops !== null` instead.
      *
-     * @category Dictionary Expression
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     */
-    get keys(): IterableIterator<string> | null;
-    /**
+     * @category Function Expression
      *
-     * @category Dictionary Expression
      */
-    get keysCount(): number;
-    /**
-     * If this expression is a dictionary, return the value of the `key` entry.
+    readonly nops: number;
+    /** First operand, i.e.`this.ops[0]`
      *
-     * @category Dictionary Expression
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     */
-    getKey(key: string): BoxedExpression | undefined;
-    /**
-     * If this expression is a dictionary, return true if the dictionary has a
-     * `key` entry.
+     * @category Function Expression
      *
-     * @category Dictionary Expression
      *
      */
-    hasKey(key: string): boolean;
-    /**
-     * Return the value of this number or symbol, if stored as a machine number.
+    readonly op1: BoxedExpression;
+    /** Second operand, i.e.`this.ops[1]`
      *
-     * 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.
+     * **Note** applicable to canonical and non-canonical expressions.
      *
-     * If `machineValue` is not `null`, then `decimalValue`, `rationalValue`
-     * and `complexValue` are `null.
+     * @category Function Expression
      *
-     * @category Numeric Expression
      *
      */
-    get machineValue(): number | null;
-    /** If the value of this expression is a rational number, return it.
-     * Otherwise, return `[null, null]`.
+    readonly op2: BoxedExpression;
+    /** Third operand, i.e. `this.ops[2]`
      *
-     * If `rationalValue` is not `[null, null]`, then `machineValue`, `decimalValue`
-     * and `complexValue` are `null.
+     * **Note** applicable to canonical and non-canonical expressions.
+     *
+     * @category Function Expression
      *
-     * @category Numeric Expression
      *
      */
-    get rationalValue(): [numer: number, denom: number] | [null, null];
-    /** If the value of this expression is a `Decimal` number, return it.
-     * Otherwise, return `null`.
+    readonly op3: BoxedExpression;
+    /** `true` if this expression or any of its subexpressions is an `["Error"]`
+     * expression.
      *
-     * A `Decimal` number is an arbitrarily long floating point number.
+     * **Note** applicable to canonical and non-canonical expressions. For
+     * non-canonical expression, this may indicate a syntax error while parsing
+     * LaTeX. For canonical expression, this may indicate argument domain
+     * mismatch, or missing or unexpected arguments.
      *
-     * If `decimalValue` is not `null`, then `machineValue`
-     * and `complexValue` are `null` and `rationalValue` is `[null, null]`.
-     *
-     * @category Numeric Expression
+     * @category Symbol Expression
      *
      */
-    get decimalValue(): Decimal | null;
-    /** If the value of this expression is a `Complex` number, return it.
-     * Otherwise, return `null`.
+    readonly isValid: boolean;
+    /**
+     * If `true`, this expression represents a value that was not calculated
+     * and that does not reference another expression.
      *
-     * If `complexValue` is not `null`, then `machineValue`, `rationalValue`
-     * and `decimalValue` are `null.
+     * This means the expression is either a number, a string or a dictionary.
+     * Functions and symbols are not literals.
      *
-     * @category Numeric Expression
+     * **Note** applicable to canonical and non-canonical expressions.
+     */
+    readonly isLiteral: boolean;
+    /** 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 `this.isPure` is `false`, `this.value` is undefined. Call
+     * `this.evaluate()` to determine the value of the expression instead.
+     *
+     * As an example, the `Random` function is not pure.
      *
+     * **Note** applicable to canonical and non-canonical expressions.
      */
-    get complexValue(): Complex | null;
-    /** Return an approximation of the numeric value of this expression as
-     * a 64-bit floating point number.
+    readonly isPure: boolean;
+    /** True if the expression is a free variable, that is a symbol with no value */
+    readonly isFree: boolean;
+    /** True if the expression is a constant, that is a symbol with an immutable value */
+    readonly isConstant: boolean;
+    /**
+     * Return the canonical form of this expression.
      *
-     * If the value is a machine number, return it exactly.
+     * If a function, after putting all the arguments in canonical form, find
+     * a corresponding function definition in the current context.
      *
-     * If the value is a rational number, return the numerator divided by the
-     * denominator.
+     * Apply 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.
      *
-     * 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.
+     * Additionally, some simplifications involving exact computations on
+     * small integers may be performed.
      *
-     * If the value of this expression cannot be represented by a float,
-     * return `null`.
+     * For example:
+     * - \\( 2 + x + 1 \longrightarrow x + 3 \\)
+     * - \\( \sqrt{4} \longrightarrow 2 \\)
+     * - \\(\frac{4}{10} \longrightarrow \frac{2}{5} \\).
      *
-     * @category Numeric Expression
+     * However, no calculation is performed involving floating point numbers, so
+     * \\( \sqrt(2) \longrightarrow \sqrt(2) \\).
      *
+     * **Note** applicable to canonical and non-canonical expressions.
+     * Expressions that are already canonical return themselves.
      *
      */
-    get asFloat(): number | null;
+    get canonical(): BoxedExpression;
     /**
-     * If the value of this expression is an integer with a 'small' absolute value,
-     * return this value. Otherwise, return `null`.
+     * If this expression is a function, apply the function `fn` to all its operands.
      *
-     * 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.
+     * Replace the head of this expression with `head`, if defined.
      *
-     * By default, "small" is less than 10,000.
+     * If this expression is a dictionary, return a new dictionary with the values
+     * modified by `fn`.
      *
-     * @category Numeric Expression
+     * If `head` is provided, return a function expression with the modified
+     * dictionary as operand, otherwise return the  modified dictionary.
      *
-     */
-    get asSmallInteger(): number | null;
+     * **Note** applicable to canonical and non-canonical expressions.
+     *
+     * */
+    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
     /**
-     * If the value of this an expression is a small integer or a rational,
-     * return this value. Otherwise, return `[null, null`].
+     * Replace all the symbols in the expression as indicated.
      *
-     * @category Numeric Expression
+     * Note the same effect can be achieved with `this.replace()`, but
+     * using `this.subs()` is more efficient, and simpler.
+     *
+     * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    get asRational(): [number, number] | [null, null];
+    subs(sub: Substitution): BoxedExpression;
     /**
-     * Return the following, depending on the value of this expression:
+     * Transform the expression by applying the rules:
+     * if the `lhs` of a rule matches, it is replaced by its `rhs`.
      *
-     * * `-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)
+     * If no rules apply, return `null`.
      *
-     * Note that complex numbers have no natural ordering,
-     * so if the value is a complex number, `sgn` is either 0, or `null`
+     * See also `subs` for a simple substitution.
      *
-     * If a symbol, this does take assumptions into account, that is `this.sgn` will return
-     * `1` if `isPositive` is `true`, even if this expression has no value
      *
-     * @category Numeric Expression
+     * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    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`.
-     *
-     * @category Symbol Expression
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression;
+    /**
+     * True if the expression includes a symbol `v` or a function head `v`.
      *
+     * **Note** applicable to canonical and non-canonical expressions.
      */
-    get symbol(): string | null;
-    /**  Shortcut for `this.symbol === "Missing"`
-     *
-     * @category Symbol Expression
+    has(v: string | string[]): boolean;
+    /** Structural/symbolic equality (weak equality).
      *
-     */
-    get isMissing(): boolean;
-    /** If this expression is a string, return the value of the string.
-     * Otherwise, return `null`.
+     * `ce.parse('1+x').isSame(ce.parse('x+1'))` is `false`
      *
-     * @category String Expression
+     * **Note** applicable to canonical and non-canonical expressions.
      *
+     * @category Relational Operator
      */
-    get string(): string | null;
-    /** True if the value of this expression is a number.
+    isSame(rhs: BoxedExpression): boolean;
+    /** Attempt to match this expression to the `rhs` expression.
      *
-     * `isExtendedComplex || isNaN` = `isReal || isImaginary || isInfinity || isNaN`
+     * If `rhs` does not match, return `null`.
      *
-     * Note that in a fateful twist of cosmic irony, `NaN` ("Not a Number")
-     * is a number.
+     * Otherwise return an object literal.
      *
-     * @category Expression Properties
-     */
-    get isNumber(): boolean | undefined;
-    /** The value of this expression is an element of the set ℤ: ...,-2, -1, 0, 1, 2...
+     * If this expression includes wildcards (symbols with a name that starts
+     * with `_`), the object literal will include a prop for each matching named
+     * wildcard.
      *
+     * If `rhs` matches this pattern but there are no named wildcards, return
+     * the empty object literal, `{}`.
      *
-     * @category Expression Properties
+     * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    get isInteger(): boolean | undefined;
-    /** The value of this expression is an element of the set ℚ, p/q with p ∈ ℕ, q ∈ ℤ ⃰  q >= 1
+    match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    /**
+     * "Not a Number".
      *
-     * Note that every integer is also a rational.
+     * A value representing undefined result of computations, such as `0/0`,
+     * as per the floating point format standard IEEE-754.
      *
+     * Note that if `isNaN` is true, `isNumber` is also true (yes, `NaN` is a
+     * number).
      *
      * @category Expression Properties
      *
      */
-    get isRational(): boolean | undefined;
+    readonly isNaN: 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.
-     *
+     * The numeric value of this expression is 0.
      *
      * @category Expression Properties
-     *
      */
-    get isAlgebraic(): boolean | undefined;
+    readonly isZero: boolean | undefined;
     /**
-     * The value of this expression is real number: finite and not imaginary.
-     *
-     * `isFinite && !isImaginary`
-     *
-     *
+     * The numeric value of this expression is not 0.
      * @category Expression Properties
      */
-    get isReal(): boolean | undefined;
-    /** Real or ±Infinity
-     *
-     * `isReal || isInfinity`
-     *
-     *
+    readonly isNotZero: boolean | undefined;
+    /**
+     * The numeric value of this expression is not 1.
      * @category Expression Properties
      */
-    get isExtendedReal(): boolean | undefined;
+    readonly isOne: boolean | undefined;
     /**
-     * The value of this expression is a number, but not `NaN` or any Infinity
-     *
-     * `isReal || isImaginary`
-     *
-     *
+     * The numeric value of this expression is not -1.
      * @category Expression Properties
-     *
      */
-    get isComplex(): boolean | undefined;
-    /** `isReal || isImaginary || isInfinity`
-     *
+    readonly isNegativeOne: boolean | undefined;
+    /** The numeric value of this expression is ±Infinity or Complex Infinity
      *
      * @category Expression Properties
      */
-    get isExtendedComplex(): boolean | undefined;
-    /** The value of this expression is a number with a imaginary part
-     *
+    readonly isInfinity: boolean | undefined;
+    /** This expression is a number, but not ±Infinity and not `NaN`
      *
      * @category Expression Properties
      */
-    get isImaginary(): boolean | undefined;
+    readonly isFinite: boolean | undefined;
     /**
      * @category Expression Properties
      */
-    get isZero(): boolean | undefined;
+    readonly isEven: boolean | undefined;
     /**
      * @category Expression Properties
      */
-    get isNotZero(): boolean | undefined;
+    readonly isOdd: boolean | undefined;
     /**
      * @category Expression Properties
      */
-    get isOne(): boolean | undefined;
+    readonly isPrime: boolean | undefined;
     /**
      * @category Expression Properties
      */
-    get isNegativeOne(): boolean | undefined;
-    /** ±Infinity or Complex Infinity
-     *
-     * @category Expression Properties
-     */
-    get isInfinity(): boolean | undefined;
+    readonly isComposite: boolean | undefined;
     /**
-     * "Not a Number".
+     * Return the value of this expression, if stored as a machine
+     * number.
      *
-     * A value representing undefined result of computations, such as `0/0`,
-     * as per the floating point format standard IEEE-754.
+     * 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.
      *
-     * Note that if `isNaN` is true, `isNumber` is also true (yes, `NaN` is a
-     * number).
+     * If `machineValue` is not `null`, then `decimalValue`, `rationalValue`
+     * and `complexValue` are `null.
      *
-     * @category Expression Properties
+     * @category Numeric Expression
      *
      */
-    get isNaN(): boolean | undefined;
-    /** Not ±Infinity and not `NaN`
+    readonly 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.
+     *
+     * @category Numeric Expression
      *
-     * @category Expression Properties
-     */
-    get isFinite(): boolean | undefined;
-    /**
-     * @category Expression Properties
-     */
-    get isEven(): boolean | undefined;
-    /**
-     * @category Expression Properties
      */
-    get isOdd(): boolean | undefined;
-    /**
-     * @category Expression Properties
+    readonly 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]`.
+     *
+     * @category Numeric Expression
+     *
      */
-    get isPrime(): boolean | undefined;
-    /**
-     * @category Expression Properties
+    readonly 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.
+     *
+     * @category Numeric Expression
+     *
+     *
      */
-    get isComposite(): boolean | undefined;
-    /** Structural/symbolic equality (weak equality).
+    readonly 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 return an approximation of the decimal
+     * number to a machine number. There might be a loss of precision or a
+     * round to 0 or Infinity, depending on the value.
+     *
+     * If the value of this expression cannot be represented by a float,
+     * return `null`.
+     *
+     * @category Numeric Expression
      *
-     * `ce.parse('1+x').isSame(ce.parse('x+1'))` is `false`
      *
-     * @category Relational Operator
      */
-    isSame(rhs: BoxedExpression): boolean;
+    readonly asFloat: number | null;
     /**
-     * True if the expression includes a symbol `v` or a function head `v`.
-     */
-    has(v: string | string[]): boolean;
-    /** Attempt to match this expression to the `rhs` expression.
+     * If the value of this expression is an integer with a 'small' absolute
+     * value, return this value. Otherwise, return `null`.
      *
-     * If `rhs` does not match, 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.
      *
-     * Otherwise return an object literal.
+     * By default, "small" is less than 1,000,000.
      *
-     * If this expression includes wildcards (symbols with a name that starts
-     * with `_`), the object literal will include a prop for each matching named
-     * wildcard.
+     * @category Numeric Expression
      *
-     * 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.
+    readonly asSmallInteger: number | null;
+    /**
+     * If the value of this an expression is a small integer or a rational,
+     * return this value. Otherwise, return `[null, null]`.
+     *
+     * @category Numeric Expression
+     *
+     */
+    readonly 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)
      *
-     * Both expressions are numerically evaluated.
+     * Note that complex numbers have no natural ordering,
+     * so if the value is a complex number, `sgn` is either 0, or `null`
      *
-     * Numbers whose difference is less than `engine.tolerance` are
-     * considered equal. This tolerance is set when the `engine.precision` is
-     * changed to be such that the last two digits are ignored.
+     * If a symbol, this does take assumptions into account, that is `this.sgn`
+     * will return `1` if `isPositive` is `true`, even if this expression has
+     * no value
+     *
+     * @category Numeric Expression
      *
-     * @category Relational Operator
      */
-    isEqual(rhs: BoxedExpression): boolean;
-    /** If the expressions cannot be compared, `undefined` is returned
+    readonly sgn: -1 | 0 | 1 | undefined | null;
+    /** If the expressions cannot be compared, return `undefined`
+     *
+     * The numeric value of both expressions are compared.
      *
      * @category Relational Operator
      */
     isLess(rhs: BoxedExpression): boolean | undefined;
     /**
+     * The numeric value of both expressions are compared.
      * @category Relational Operator
      */
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     /**
+     * The numeric value of both expressions are compared.
      * @category Relational Operator
      */
     isGreater(rhs: BoxedExpression): boolean | undefined;
     /**
+     * The numeric value of both expressions are compared.
      * @category Relational Operator
      */
     isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
-    /** The value of this expression is > 0, same as `isGreater(0)`
+    /** The numeric value of this expression is > 0, same as `isGreater(0)`
      *
      * @category Expression Properties
      */
-    get isPositive(): boolean | undefined;
-    /** The value of this expression is  >= 0, same as `isGreaterEqual(0)`
+    readonly isPositive: boolean | undefined;
+    /** The numeric value of this expression is >= 0, same as `isGreaterEqual(0)`
      *
      * @category Expression Properties
      */
-    get isNonNegative(): boolean | undefined;
-    /** The value of this expression is  < 0, same as `isLess(0)`
+    readonly isNonNegative: boolean | undefined;
+    /** The numeric value of this expression is < 0, same as `isLess(0)`
      *
      * @category Expression Properties
      */
-    get isNegative(): boolean | undefined;
-    /** The value of this expression is  <= 0, same as `isLessEqual(0)`
+    readonly isNegative: boolean | undefined;
+    /** The numeric value of this expression is <= 0, same as `isLessEqual(0)`
      *
      * @category Expression Properties
      */
-    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);
+    readonly isNonPositive: boolean | undefined;
+    /** The keys of the dictionary.
+     *
+     * If this expression not a dictionary, return `null`
+     *
+     * @category Dictionary Expression
+     *
+     */
+    readonly keys: IterableIterator<string> | null;
+    /**
+     *
+     * @category Dictionary Expression
+     */
+    readonly keysCount: number;
+    /**
+     * If this expression is a dictionary, return the value of the `key` entry.
+     *
+     * @category Dictionary Expression
+     *
+     */
+    getKey(key: string): BoxedExpression | undefined;
+    /**
+     * If this expression is a dictionary, return true if the
+     *  dictionary has a `key` entry.
+     *
+     * @category Dictionary Expression
+     *
+     */
+    hasKey(key: string): boolean;
+    /** Wikidata identifier.
+     *
+     * **Note** `undefined` if not a canonical expression.
+     *
+     *
+     */
+    get wikidata(): string | undefined;
+    set wikidata(val: string | undefined);
+    /** An optional short description if the symbol or function head.
+     *
+     * May include markdown. Each string is a paragraph.
+     *
+     * **Note** `undefined` if not a canonical expression.
+     *
+     */
+    readonly description: undefined | string[];
+    /** An optional URL pointing to more information about the symbol or
+     *  function head
+     *
+     * **Note** `undefined` if not a canonical expression.
+     *
+     */
+    readonly url: string | undefined;
     /** Expressions with a higher complexity score are sorted
      * first in commutative functions
+     *
+     * **Note** `undefined` if not a canonical expression.
      */
-    get complexity(): number;
-    /** The domain of this expression. */
-    get domain(): Domain;
-    /** Symbols that represent a variable, can have their domain modified */
-    set domain(domain: Domain | string);
-    /** The domain of the value of this expression, using the value of the expression,
-     * definitions associated with this expression and assumptions if necessary.
+    readonly complexity: number | undefined;
+    /**
+     * For symbols and functions, a possible definition associated with the
+     *  expression. `basedDefinition` is the base class of symbol and function
+     *  definition.
+     *
+     * **Note** `undefined` if not a canonical expression.
      *
-     * For symbols, the `domain` and `valueDomain` are the same.  For functions,
-     * the `valueDomain` is the codomain of the function.
      */
-    get valueDomain(): Domain;
-    /** For symbols and functions, a possible definition associated with the expression */
-    get functionDefinition(): BoxedFunctionDefinition | undefined;
-    get symbolDefinition(): BoxedSymbolDefinition | undefined;
+    readonly basedDefinition: BoxedBaseDefinition | undefined;
     /**
-     * Return the canonical form of this expression.
+     * For functions, a possible definition associated with the 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.
+     * **Note** `undefined` if not a canonical expression or not a function.
      *
-     * Additionally, some simplifications involving exact computations on
-     * small integers may be performed.
+     */
+    readonly functionDefinition: BoxedFunctionDefinition | undefined;
+    /**
+     * For symbols, a possible definition associated with the expression.
      *
-     * For example:
-     * - \\( 2 + x + 1 \longrightarrow x + 3 \\)
-     * - \\( \sqrt{4} \longrightarrow 2 \\)
-     * - \\(\frac{4}{10} \longrightarrow \frac{2}{5} \\).
+     * **Note** `undefined` if not a symbol
      *
-     * However, no calculation is performed involving floating point numbers, so
-     * \\( \sqrt(2) \longrightarrow \sqrt(2) \\).
+     */
+    readonly symbolDefinition: BoxedSymbolDefinition | undefined;
+    /**
+     * The domain of this expression, without accounting for any inferred domain
+     * or `ce.defaultDomain`. If no domain has been explicitly set via assignment
+     * or via an `.assume()` directive, the `expr.explicitDomain` is `undefined`.
+     *
+     * This is useful to determine if the domain of an expression is inferred.
+     *
+     * In most cases you'll want to  use `expr.domain` instead.
+     *
+     * **Note** `undefined` if not a canonical expression or not a function.
      *
-     * Determining the canonical form does not depend on the values assigned to,
-     * or assumptions about, symbols.
      */
-    get canonical(): BoxedExpression;
+    readonly explicitDomain: BoxedDomain | undefined;
+    /**
+     * Update the definition associated with this expression, taking
+     * into account the specified scope.
+     *
+     * **Note**: applicable only to canonical expressions
+     *
+     * @internal
+     */
+    bind(scope: RuntimeScope | null): void;
+    /**
+     *
+     * @internal
+     */
+    unbind(): void;
     /**
      * Return a simpler form of this expression.
      *
@@ -830,45 +922,141 @@ export interface BoxedExpression {
     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.
+     * Synonym for `evaluate()`. If the expression is pure, the value may be
+     * cached.
      *
-     * If this expression is a dictionary, return a new dictionary with the values
-     * modified by `fn`.
+     * It returns `undefined` for expressions that are not pure or that may
+     * not be evaluated.
      *
-     * 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;
+     * **Note**: If non-canonical, return the value of its canonical counterpart
+     */
+    get value(): BoxedExpression | undefined;
+    /** Only the value of variables can be changed (symbols that are not
+     * constants).
+     *
+     * **Note**: If non-canonical, does nothing.
+     *
+     */
+    set value(value: BoxedExpression | number | undefined);
+    /** An approximation of the value of this expression. Floating-point
+     * operations may be performed.
+     *
+     * Just like `this.value`, it returns `undefined` for expressions that are
+     * not pure.
+     *
+     * **Note**: If non-canonical, return the numeric value of its canonical
+     * counterpart
+     */
+    readonly numericValue: BoxedExpression | undefined;
+    /** The domain of the value of this expression.
+     *
+     * If a function expression, the domain  of the value of the function (the codomain of the function).
+     *
+     * If a symbol the domain of the value of the symbol.
+     *
+     * Use `expr.head` to determine if an expression is a symbol or function.
+     *
+     * **Note**: If non-canonical, return the domain of its canonical
+     * counterpart
+     */
+    get domain(): BoxedDomain;
+    /** Modify the domain of a symbol that represent a variable
+     * (or a function name).
+     *
+     * **Note**: If non-canonical, does nothing.
+     *
+     */
+    set domain(domain: BoxedDomain | string);
+    /** `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.
+     *
+     * @category Domain Properties
+     */
+    readonly isNumber: boolean | undefined;
+    /** The value of this expression is an element of the set ℤ: ...,-2, -1, 0, 1, 2...
+     *
+     *
+     * @category Domain Properties
+     *
+     */
+    readonly 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.
+     *
+     *
+     * @category Domain Properties
+     *
+     */
+    readonly isRational: boolean | undefined;
     /**
-     * Transform the expression by according to the rules:
-     * the matching `lhs` of a rule is replaced by its `rhs`.
+     * The value of this expression is a number that is the root of a non-zero
+     * univariate polynomial with rational coefficients.
      *
-     * If no rules apply, return `null`.
+     * All integers and rational numbers are algebraic.
+     *
+     * Transcendental numbers, such as \\( \pi \\) or \\( e \\) are not algebraic.
+     *
+     *
+     * @category Domain Properties
      *
-     * See also `subs` for a simple substitution.
      */
-    replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression;
+    readonly isAlgebraic: boolean | undefined;
     /**
-     * Replace all the symbols in the expression as indicated.
+     * The value of this expression is real number: finite and not imaginary.
+     *
+     * `isFinite && !isImaginary`
      *
-     * Note the same effect can be achieved with `this.replace()`, but
-     * using `this.subs()` is more efficient, and simpler.
      *
+     * @category Domain Properties
      */
-    subs(sub: Substitution): BoxedExpression;
+    readonly isReal: boolean | undefined;
+    /** Real or ±Infinity
+     *
+     * `isReal || isInfinity`
+     *
+     *
+     * @category Domain Properties
+     */
+    readonly isExtendedReal: boolean | undefined;
     /**
-     * Update the definition associated with this expression, taking
-     * into account the current context.
+     * The value of this expression is a number, but not `NaN` or any Infinity
+     *
+     * `isReal || isImaginary`
+     *
+     *
+     * @category Domain Properties
      *
-     * @internal
      */
-    _repairDefinition(): void;
-    /** Purge any cached values.
+    readonly isComplex: boolean | undefined;
+    /** `isReal || isImaginary || isInfinity`
      *
-     * @internal
+     *
+     * @category Domain Properties
+     */
+    readonly isExtendedComplex: boolean | undefined;
+    /** The value of this expression is a number with a imaginary part
+     *
+     *
+     * @category Domain Properties
+     */
+    readonly isImaginary: boolean | undefined;
+    /** Mathematical equality (strong equality), that is the value
+     * of this expression and of `rhs` are numerically equal.
+     *
+     * The numeric value of both expressions are compared.
+     *
+     * Numbers whose difference is less than `engine.tolerance` are
+     * considered equal. This tolerance is set when the `engine.precision` is
+     * changed to be such that the last two digits are ignored.
+     *
+     * @category Relational Operator
      */
-    _purge(): undefined;
+    isEqual(rhs: BoxedExpression): boolean;
 }
 /** A semi boxed expression is an MathJSON expression which can include some
  * boxed terms.
@@ -893,7 +1081,7 @@ export interface Pattern extends BoxedExpression {
      * 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;
+    match(expr: BoxedExpression, options?: PatternMatchOption): BoxedSubstitution | 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 */
@@ -909,25 +1097,25 @@ export interface ExpressionMapInterface<U> {
     [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
 }
 /**
- * A dictionary contains definitions for symbols, functions and rules.
+ * A symbol table contains definitions for symbols, functions and rules.
  *
  */
-export declare type Dictionary = {
+export declare type SymbolTable = {
     symbols?: SymbolDefinition[];
     functions?: FunctionDefinition[];
     simplifyRules?: BoxedRuleSet;
 };
 /**
- * The entries of a `CompiledDictionary` have been validated and
+ * The entries of a `RuntimeSymbolTable` 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 `RuntimeDictionary` are created as needed.
  */
-export declare type RuntimeDictionary = {
+export declare type RuntimeSymbolTable = {
     symbols: Map<string, BoxedSymbolDefinition>;
     symbolWikidata: Map<string, BoxedSymbolDefinition>;
-    functions: Map<string, BoxedFunctionDefinition[]>;
+    functions: Map<string, BoxedFunctionDefinition>;
     functionWikidata: Map<string, BoxedFunctionDefinition>;
 };
 /**
@@ -976,7 +1164,7 @@ export declare type Scope = {
 };
 export declare type RuntimeScope = Scope & {
     parentScope: RuntimeScope;
-    dictionary?: RuntimeDictionary;
+    symbolTable?: RuntimeSymbolTable;
     assumptions: undefined | ExpressionMapInterface<boolean>;
     /** The location of the call site that created this scope */
     origin?: {
@@ -995,9 +1183,9 @@ export declare type BaseDefinition = {
      * 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
+     * - Use only letters, digits and `-`: `/[a-zA-Z0-9-]+/`
+     * - The first character should be a letter: `/^[a-zA-Z]/`
+     * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
      *
      */
     name: string;
@@ -1012,25 +1200,8 @@ export declare type BaseDefinition = {
      * 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 signature of the function
-     *
-     * When `domain` is a handler, calculate the domain (or signature) based on
-     * the arguments (for expressions others than functions, `args` is an empty
-     * array). If the function cannot be applied to the arguments, return
-     * `null`.
-     */
-    domain?: Domain | DomainExpression | string | ((ce: IComputeEngine, args: BoxedExpression[]) => Domain | DomainExpression);
 };
-export declare type BoxedBaseDefinition = {
+export interface BoxedBaseDefinition {
     name: string;
     wikidata?: string;
     description?: string | string[];
@@ -1041,32 +1212,35 @@ export declare type BoxedBaseDefinition = {
      * This field is usually undefined, but its value is set by `getDefinition()`
      */
     scope: RuntimeScope | undefined;
-    domain?: Domain | ((ce: IComputeEngine, args: BoxedExpression[]) => Domain | DomainExpression);
-    _purge(): undefined;
-};
+    /** When the environment changes, for example the numerical precision,
+     * call `reset()` so that any cached values can be recalculated.
+     */
+    reset(): any;
+}
 /**
  * A function definition can have some flags to indicate specific
  * properties of the function.
  */
 export declare type FunctionDefinitionFlags = {
-    /**  If true, the function is applied element by element to lists, matrices
-     * and equations.
+    /**  If `true`, the function is applied element by element to lists, matrices
+     * (`["List"]` or `["Tuple"]` expressions) and equations (relational
+     * operators).
      *
      * **Default**: `false`
      */
     threadable: boolean;
-    /** If true, `["f", ["f", a], b]` simplifies to `["f", a, b]`
+    /** If `true`, `["f", ["f", a], b]` simplifies to `["f", a, b]`
      *
      * **Default**: `false`
      */
     associative: boolean;
-    /** If true, `["f", a, b]` equals `["f", b, a]`. The canonical
+    /** If `true`, `["f", a, b]` equals `["f", b, a]`. The canonical
      * version of the function will order the arguments.
      *
      * **Default**: `false`
      */
     commutative: boolean;
-    /** If true, when the function is univariate, `["f", ["Add", x, c]]` where `c`
+    /** If `true`, when the function is univariate, `["f", ["Add", x, c]]` where `c`
      * is constant, is simplified to `["Add", ["f", x], c]`.
      *
      * When the function is multivariate, additivity is considered only on the
@@ -1076,7 +1250,7 @@ export declare type FunctionDefinitionFlags = {
      *
      * **Default**: `false`
      */
-    /** If true, when the function is univariate, `["f", ["Multiply", x, y]]`
+    /** If `true`, when the function is univariate, `["f", ["Multiply", x, y]]`
      * simplifies to `["Multiply", ["f", x], ["f", y]]`.
      *
      * When the function is multivariate, multiplicativity is considered only on the
@@ -1085,26 +1259,26 @@ export declare type FunctionDefinitionFlags = {
      *
      * **Default**: `false`
      */
-    /** If true, when the function is univariate, `["f", ["Multiply", x, c]]`
+    /** If `true`, when the function is univariate, `["f", ["Multiply", x, c]]`
      * simplifies to `["Multiply", ["f", x], c]` where `c` is constant
      *
-     * When the function is multivariate, multiplicativity is considered only on the
-     * first argument: `["f", ["Multiply", x, y], z]` simplifies to
+     * 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`
      */
-    /** If true, `["f", ["f", x]]` simplifies to `["f", x]`.
+    /** If `true`, `["f", ["f", x]]` simplifies to `["f", x]`.
      *
      * **Default**: `false`
      */
     idempotent: boolean;
-    /** If true, `["f", ["f", x]]` simplifies to `x`.
+    /** If `true`, `["f", ["f", x]]` simplifies to `x`.
      *
      * **Default**: `false`
      */
     involution: boolean;
-    /** If true, the value of this function is always the same for a given
+    /** 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
@@ -1114,7 +1288,7 @@ export declare type FunctionDefinitionFlags = {
      *
      * This information may be used to cache the value of expressions.
      *
-     * **Default:** true
+     * **Default:** `true`
      */
     pure: boolean;
     /**
@@ -1125,46 +1299,30 @@ export declare type FunctionDefinitionFlags = {
      * **Default:** false
      */
     inert: boolean;
-};
-/**
- * Definition record for a function.
- *
- */
-export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
-    /**
-     * A number used to order arguments. Argument with higher
-     * complexity are placed after arguments with lower complexity when
-     * ordered canonically in commutative functions.
-     *
-     * - 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
-     */
-    complexity?: number;
     /**
-     * - `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
+     * All the arguments of a numeric function are numeric,
+     * and its value is numeric.
      */
-    hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    numeric: boolean;
     /**
-     * If true, `Sequence` arguments appearing in the arguments of a function
-     * should not automatically be flattened out
+     * When true, evaluating the function create a temporary scope.
+     * This is used for example by the `Lambda` function to keep track of the
+     * inferred domain of its wildcard  `_` arguments
      */
-    sequenceHold?: boolean;
+    scoped: boolean;
+};
+/**
+ *
+ */
+export declare type FunctionSignature = {
+    /** The domain of this signature, a domain compatible with the `Function`
+     * domain) */
+    domain?: BoxedDomain | DomainExpression;
     /** The minimum and maximum values of the result of the function */
-    range?: [min: number, max: number];
+    /** An optional handler to determine the codomain of the function.
+     * If not provided, the codomain of the function is determined from `domain`
+     */
+    codomain?: (ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null;
     /**
      * Return the canonical form of the expression with the arguments `args`.
      *
@@ -1284,11 +1442,9 @@ export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefini
     /** 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];
+export declare type BoxedFunctionSignature = {
+    domain: BoxedDomain;
+    codomain?: BoxedDomain | ((ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null);
     canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
     simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
     evaluate?: BoxedLambdaExpression | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined);
@@ -1297,6 +1453,50 @@ export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefi
     sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
+/**
+ * Definition record for a function.
+ *
+ */
+export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
+    /**
+     * A number used to order arguments.
+     *
+     * Argument with higher complexity are placed after arguments with lower
+     * complexity when ordered canonically in commutative functions.
+     *
+     * - 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
+     */
+    complexity?: number;
+    /**
+     * - `"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
+     * - `"last"`: The last argument is not evaluated, the others are
+     * - `"most"`: All the arguments are evaluated, except the last one
+     *
+     * **Default**: `"none"`
+     */
+    hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    signature?: FunctionSignature;
+};
+export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
+    complexity: number;
+    hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    signature: BoxedFunctionSignature;
+};
 /**
  * When used in a `SymbolDefinition`, these flags are optional.
  *
@@ -1340,7 +1540,7 @@ export declare type SymbolDefinitionFlags = {
      */
     constant: boolean;
     /**
-     * If false, the value of the symbol is substituted during canonicalization
+     * 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()`.
@@ -1358,11 +1558,12 @@ export declare type SymbolDefinition = BaseDefinition & Partial<SymbolFlags> & P
      * `Pi`, the actual value depends on the `precision` setting of the
      * `ComputeEngine` */
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    domain?: string | Domain;
+    domain?: string | BoxedDomain;
 };
 export interface BoxedSymbolDefinition extends BoxedBaseDefinition, Partial<SymbolFlags>, SymbolDefinitionFlags {
     get value(): BoxedExpression | undefined;
     set value(val: BoxedExpression | undefined);
+    domain: BoxedDomain | undefined;
     at?: (index: string | number) => undefined | BoxedExpression;
 }
 export declare type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
@@ -1379,41 +1580,41 @@ export interface ComputeEngineStats {
 /** @internal */
 export interface IComputeEngine {
     /** @internal */
-    readonly ZERO: BoxedExpression;
+    readonly _ZERO: BoxedExpression;
     /** @internal */
-    readonly ONE: BoxedExpression;
+    readonly _ONE: BoxedExpression;
     /** @internal */
-    readonly TWO: BoxedExpression;
+    readonly _TWO: BoxedExpression;
     /** @internal */
-    readonly HALF: BoxedExpression;
+    readonly _HALF: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_ONE: BoxedExpression;
+    readonly _NEGATIVE_ONE: BoxedExpression;
     /** @internal */
-    readonly I: BoxedExpression;
+    readonly _I: BoxedExpression;
     /** @internal */
-    readonly NAN: BoxedExpression;
+    readonly _NAN: BoxedExpression;
     /** @internal */
-    readonly POSITIVE_INFINITY: BoxedExpression;
+    readonly _POSITIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_INFINITY: BoxedExpression;
+    readonly _NEGATIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly COMPLEX_INFINITY: BoxedExpression;
+    readonly _COMPLEX_INFINITY: BoxedExpression;
     /** @internal */
-    readonly DECIMAL_NAN: Decimal;
+    readonly _DECIMAL_NAN: Decimal;
     /** @internal */
-    readonly DECIMAL_ZERO: Decimal;
+    readonly _DECIMAL_ZERO: Decimal;
     /** @internal */
-    readonly DECIMAL_ONE: Decimal;
+    readonly _DECIMAL_ONE: Decimal;
     /** @internal */
-    readonly DECIMAL_TWO: Decimal;
+    readonly _DECIMAL_TWO: Decimal;
     /** @internal */
-    readonly DECIMAL_HALF: Decimal;
+    readonly _DECIMAL_HALF: Decimal;
     /** @internal */
-    readonly DECIMAL_PI: Decimal;
+    readonly _DECIMAL_PI: Decimal;
     /** @internal */
-    readonly DECIMAL_NEGATIVE_ONE: Decimal;
+    readonly _DECIMAL_NEGATIVE_ONE: Decimal;
     /** The current scope */
-    context: RuntimeScope;
+    context: RuntimeScope | null;
     /** Absolute time beyond which evaluation should not proceed
      * @internal
      */
@@ -1424,7 +1625,7 @@ export interface IComputeEngine {
     readonly iterationLimit: number;
     /** @experimental */
     readonly recursionLimit: number;
-    defaultDomain: null | Domain;
+    defaultDomain: null | BoxedDomain;
     /** {@inheritDoc  NumericMode} */
     numericMode: NumericMode;
     tolerance: number;
@@ -1445,13 +1646,17 @@ export interface IComputeEngine {
      * If a definition existed previously, it is replaced.
      */
     defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
-    getSymbolDefinition(name: string, wikidata?: string): undefined | BoxedSymbolDefinition;
     /**
-     * Return `undefined` if no definition exist for this `head.
+     * Associate a new definition to a function in the current context.
+     *
+     * If a definition existed previously, it is replaced.
      */
-    getFunctionDefinition(head: string, args?: BoxedExpression[]): undefined | BoxedFunctionDefinition;
+    defineFunction(def: FunctionDefinition): BoxedFunctionDefinition;
+    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
+    /** Return `undefined` if no definition exist for this `head` */
+    lookupFunction(head: string, scope?: RuntimeScope): undefined | BoxedFunctionDefinition;
     /**
-     * Returned a boxed expression from the input.
+     * Return a boxed expression from the input.
      *
      * The result may not be canonical.
      */
@@ -1462,14 +1667,22 @@ export interface IComputeEngine {
     symbol(sym: string, metadata?: Metadata): BoxedExpression;
     /** Return a canonical boxed string */
     string(s: string, metadata?: Metadata): BoxedExpression;
-    /** Return a canonical boxed domain */
-    domain(domain: SemiBoxedExpression | Domain | string, metadata?: Metadata): Domain;
-    /** Return a canonical expression.
+    /** Return a canonical boxed domain.
+     *
+     * If the domain is invalid, may return an `["Error"]` expression
+     *
+     */
+    domain(domain: SemiBoxedExpression | BoxedDomain | string, metadata?: Metadata): BoxedDomain;
+    /** Return a canonical lambda expression */
+    lambda(expr: SemiBoxedExpression, sig: BoxedDomain): BoxedLambdaExpression;
+    /**
+     * 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)]))` \( \to \) 5
+     * For example:
+     * `ce.fn("Rational", [ce.number(1),  ce.number(2)]))` \( \to \) `ce.number([1,2])`
      *
      */
     fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
@@ -1480,15 +1693,15 @@ export interface IComputeEngine {
      * 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.
+     * conditions are met (i.e. `ops` properly normalized and sorted, all
+     * `ops` canonical, etc..) so that the result is actually canonical.
      */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Error"...)`.
      *
      * The result is canonical.
      */
-    error(val: BoxedExpression, message: string, messageArg: SemiBoxedExpression): any;
+    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     /** Shortcut for `this.fn("Add"...)`.
      *
      * The result is canonical.
@@ -1545,7 +1758,7 @@ export interface IComputeEngine {
      */
     serialize(expr: SemiBoxedExpression): LatexString;
     /**
-     * Options to control the serailization of MathJSON expression to LaTeX
+     * Options to control the serialization of MathJSON expression to LaTeX
      * when using `this.latex` or `this.engine.serialize()`.
      *
      *
@@ -1574,7 +1787,7 @@ export interface IComputeEngine {
      *
      *
      */
-    assume(symbol: LatexString | SemiBoxedExpression, domain: Domain): AssumeResult;
+    assume(symbol: LatexString | SemiBoxedExpression, domain: BoxedDomain): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
     assume(arg1: LatexString | SemiBoxedExpression, arg2?: BoxedExpression): AssumeResult;
     /** Remove all assumptions about one or more symbols */
@@ -1582,7 +1795,7 @@ export interface IComputeEngine {
     get assumptions(): ExpressionMapInterface<boolean>;
     ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
     pushScope(options?: {
-        dictionary?: Readonly<Dictionary> | Readonly<Dictionary>[];
+        symbolTable?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
         assumptions?: (LatexString | Expression | BoxedExpression)[];
         scope?: Partial<Scope>;
     }): void;
@@ -1605,7 +1818,7 @@ export interface IComputeEngine {
     cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
     readonly stats: ComputeEngineStats;
     /** @internal */
-    purge(): void;
+    reset(): void;
     /** @internal */
     _register(expr: BoxedExpression): void;
     /** @internal */