@cortex-js/compute-engine 0.24.0 → 0.25.0

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

@@ -1,4 +1,4 @@
-/* 0.24.0 */
+/* 0.25.0 */
  *
  * The Compute Engine is a symbolic computation engine that can be used to
  * manipulate and evaluate mathematical expressions.
@@ -12,1087 +12,8 @@
  * @module "compute-engine"
  *
  */
-import type { Complex } from 'complex.js';
-import type { Decimal } from 'decimal.js';
-import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
-import type { LatexDictionaryEntry, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-export * from './latex-syntax/public';
-export * from './compute-engine';
-/**
- * @category Boxed Expression
- */
-export type Rational = [number, number] | [bigint, bigint];
-/**
- * Metadata that can be associated with a `BoxedExpression`
- *
- * @category Boxed Expression
- */
-export type Metadata = {
-    latex?: string | undefined;
-    wikidata?: string | undefined;
-};
-/**
- * The numeric evaluation mode:
- *
-<div className="symbols-table">
-
-| Mode | |
-| :--- | :----- |
-| `"auto"`| Use bignum or complex numbers. |
-| `"machine"` |  **IEEE 754-2008**, 64-bit floating point numbers: 52-bit mantissa, about 15 digits of precision |
-| `"bignum"` | Arbitrary precision floating point numbers, as provided by the "decimal.js" library |
-| `"complex"` | Complex number represented by two machine numbers, a real and an imaginary part, as provided by the "complex.js" library |
-
-</div>
-
- * @category Compute Engine
- */
-export type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
-/** @category Compute Engine */
-export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
-/** Options for `BoxedExpression.simplify()`
- *
- * @category Compute Engine
- */
-export type SimplifyOptions = {
-    recursive?: boolean;
-    rules?: BoxedRuleSet;
-};
-/** Options for `BoxedExpression.evaluate()`
- *
- * @category Boxed Expression
- */
-export type EvaluateOptions = {
-    numericMode?: boolean;
-};
-/** Options for `BoxedExpression.N()`
- *
- * @category Boxed Expression
- */
-export type NOptions = {};
-/**
- * @category Boxed Expression
- *
- */
-export type ReplaceOptions = {
-    /** If `true`, apply replacement rules to all sub-expressions.
-     * If `false`, only consider the top-level expression.
-     *
-     * **Default**: `false`
-     */
-    recursive?: boolean;
-    /**
-     * If `true`, stop after the first rule that matches.
-     *
-     * If `false`, apply all the remaining rules even after the first match.
-     *
-     * **Default**: `false`
-     */
-    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.
-
-* @category Boxed Expression
- */
-export type Substitution<T = SemiBoxedExpression> = {
-    [symbol: string]: T;
-};
-/**
- * @category Boxed Expression
- *
- */
-export type BoxedSubstitution = Substitution<BoxedExpression>;
-/** A LaTeX string starts and end with `$`, for example
- * `"$\frac{\pi}{2}$"`.
- *
- * @category Latex Parsing and Serialization
- */
-export type LatexString = string;
-/** @category Rules */
-export type PatternReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression;
-/** @category Rules */
-export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: IComputeEngine) => boolean;
-/**
- *  A rule describes how to modify an expressions that matches a pattern `match`
- * into a new expression `replace`.
- *
- * `x-1` \( \to \) `1-x`
- * `(x+1)(x-1)` \( \to \) `x^2-1
- *
- * The `match` pattern can be expressed as a LaTeX string or a
- * MathJSON expression.
- *
- *
- * Anonymous wildcards (`_`) will match any
- * expression. Named wildcards (`_x`, `_a`, etc...) will match any expression
- * and bind the expression to the wildcard name.
- *
- * In addition the sequence wildcard (`__1`, `__a`, etc...) will match
- * a sequence of one or more expressions, and bind the sequence to the
- * wildcard name.
- *
- * @category Rules
- */
-export type Rule = {
-    match: LatexString | SemiBoxedExpression | Pattern;
-    replace: LatexString | SemiBoxedExpression | PatternReplaceFunction;
-    condition?: LatexString | PatternConditionFunction;
-    priority?: number;
-    id?: string;
-};
-/** @category Rules */
-export type BoxedRule = {
-    match: Pattern;
-    replace: BoxedExpression | PatternReplaceFunction;
-    condition: undefined | PatternConditionFunction;
-    priority: number;
-    id?: string;
-};
-/** @category Rules */
-export type BoxedRuleSet = Set<BoxedRule>;
-/** @category Boxed Expression */
-export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
-/** A domain constructor is the head of a domain expression.
- *
- * @category Boxed Expression
- *
- */
-export type DomainConstructor = 'FunctionOf' | 'ListOf' | 'DictionaryOf' | 'TupleOf' | 'Intersection' | 'Union' | 'OptArg' | 'VarArg' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
-/** @category Boxed Expression */
-export type DomainLiteral = 'Anything' | 'Values' | 'Domains' | 'Void' | 'NothingDomain' | 'Booleans' | 'Strings' | 'Symbols' | 'Collections' | 'Lists' | 'Dictionaries' | 'Sequences' | 'Tuples' | 'Sets' | 'Functions' | 'Predicates' | 'LogicOperators' | 'RelationalOperators' | 'NumericFunctions' | 'RealFunctions' | 'Numbers' | 'ComplexNumbers' | 'ExtendedRealNumbers' | 'ImaginaryNumbers' | 'Integers' | 'Rationals' | 'PositiveNumbers' | 'PositiveIntegers' | 'NegativeNumbers' | 'NegativeIntegers' | 'NonNegativeNumbers' | 'NonNegativeIntegers' | 'NonPositiveNumbers' | 'NonPositiveIntegers' | 'ExtendedComplexNumbers' | 'TranscendentalNumbers' | 'AlgebraicNumbers' | 'RationalNumbers' | 'RealNumbers';
-/** @category Boxed Expression */
-export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['ListOf', DomainExpression<T>] | ['DictionaryOf', DomainExpression<T>] | ['TupleOf', ...DomainExpression<T>[]] | ['OptArg', ...DomainExpression<T>[]] | ['VarArg', DomainExpression<T>] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['FunctionOf', ...DomainExpression<T>[]];
-/**
- * @noInheritDoc
- *
- * @category Boxed Expression
- */
-export interface BoxedDomain extends BoxedExpression {
-    get canonical(): BoxedDomain;
-    get json(): Expression;
-    /** True if a valid domain, and compatible with `dom`
-     * `kind` is '"covariant"' by default, i.e. `this <: dom`
-     */
-    isCompatible(dom: BoxedDomain | DomainLiteral, kind?: DomainCompatibility): boolean;
-    get base(): DomainLiteral;
-    get ctor(): DomainConstructor | null;
-    get params(): DomainExpression[];
-    readonly isNumeric: boolean;
-    readonly isFunction: boolean;
-}
-/**
- * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
- *
- * @category Compute Engine
- */
-export 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**: `[]`  (none)
-     */
-    metadata: ('all' | 'wikidata' | 'latex')[];
-    /** If true, repeating decimals are detected and serialized accordingly
-     * For example:
-     * - `1.3333333333333333` \( \to \) `1.(3)`
-     * - `0.142857142857142857142857142857142857142857142857142` \( \to \) `0.(1428571)`
-     *
-     * **Default**: `true`
-     */
-    repeatingDecimals: boolean;
-    /** Number literals are serialized with this precision.
-     * If `"auto"`, the same precision as the compute engine calculations is used
-     * If `"max"`, all available digits are serialized
-     *
-     * **Default**: `"auto"`
-     */
-    precision: 'auto' | 'max' | number;
-};
-/**
- * @category Boxed Expression
- */
-export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
-/**
- * :::info[THEORY OF OPERATIONS]
- *
- * The `BoxedExpression` interface includes most of the member functions
- * applicable to any kind of expression, for example `get symbol()` or
- * `get ops()`.
- *
- * When a member function is not applicable to this `BoxedExpression`,
- * for example `get symbol()` on a `BoxedNumber`, it returns `null`.
- *
- * This convention makes it convenient to manipulate expressions without
- * having to check what kind of instance they are before manipulating them.
- * :::
- *
- * To get a boxed expression, use `ce.box()` or `ce.parse()`.
- *
- * @category Boxed Expression
- *
- */
-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()`, return a primitive value for the expression.
-     *
-     * If the expression is a machine number, or bignum or rational that can be
-     * converted to a machine number, return a JavaScript `number`.
-     *
-     * If the expression is a symbol, return the name of the symbol as a `string`.
-     *
-     * Otherwise return a JavaScript primitive representation of the expression.
-     *
-     * @category Primitive Methods
-     */
-    valueOf(): number | any[] | string | boolean;
-    /** From `Object.toString()`, return a string representation of the
-     *  expression. This string is suitable to be output to the console
-     * for debugging, for example. To get a LaTeX representation of the
-     * expression, use `expr.latex`.
-     *
-     * Used when coercing a `BoxedExpression` to a `String`.
-     *
-     * @category Primitive Methods
-     */
-    toString(): string;
-    /**
-     * Output to the console a string representation of the expression.
-     *
-     * @category Primitive Methods
-     */
-    print(): void;
-    /** 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.
-     *
-     */
-    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;
-    /** For debugging, the raw MathJSON representation of this expression without decanonicalization.
-     * @internal */
-    readonly rawJson: Expression;
-    /**
-     * The scope in which this expression has been defined.
-     * Is null when the expression is not canonical.
-     */
-    readonly scope: RuntimeScope | null;
-    /** From `Object.is()`. Equivalent to `BoxedExpression.isSame()`
-     *
-     * @category Primitive Methods
-     *
-     */
-    is(rhs: unknown): boolean;
-    /** @internal */
-    readonly hash: number;
-    /** LaTeX representation of this expression.
-     *
-     * The serialization can be customized with `ComputeEngine.latexOptions`
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    get latex(): LatexString;
-    /**
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     * @internal
-     */
-    set latex(val: string);
-    /** If this expression is a symbol, return the name of the symbol as a string.
-     * Otherwise, return `null`.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-  
-    * @category Symbol Expression
-     *
-     */
-    readonly symbol: string | null;
-    /**
-     * If this is the `Nothing` symbol, return `true`.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     */
-    readonly isNothing: boolean;
-    /** If this expression is a string, return the value of the string.
-     * Otherwise, return `null`.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-  
-    * @category String Expression
-     *
-     */
-    readonly string: string | null;
-    /** All the subexpressions matching the head
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    getSubexpressions(head: string): BoxedExpression[];
-    /** All the subexpressions in this expression, recursively
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    readonly subexpressions: BoxedExpression[];
-    /**
-     *
-     * All the symbols in the expression, recursively
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    readonly symbols: string[];
-    /**
-     * All the identifiers used in the expression that do not have a value
-     * associated with them, i.e. they are declared but not defined.
-     */
-    readonly unknowns: string[];
-    /**
-     *
-     * All the identifiers (symbols and functions) in the expression that are
-     * not a local variable or a parameter of that function.
-     *
-     */
-    readonly freeVariables: string[];
-    /** All the `["Error"]` subexpressions
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    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]`.
-     */
-    readonly head: BoxedExpression | string;
-    /** The list of arguments of the function, its "tail".
-     *
-     * If the expression is not a function, return `null`.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * @category Function Expression
-     *
-     */
-    readonly 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.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * @category Function Expression
-     *
-     */
-    readonly nops: number;
-    /** First operand, i.e.`this.ops[0]`
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * @category Function Expression
-     *
-     *
-     */
-    readonly op1: BoxedExpression;
-    /** Second operand, i.e.`this.ops[1]`
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * @category Function Expression
-     *
-     *
-     */
-    readonly op2: BoxedExpression;
-    /** Third operand, i.e. `this.ops[2]`
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * @category Function Expression
-     *
-     *
-     */
-    readonly op3: BoxedExpression;
-    /** `true` if this expression or any of its subexpressions is an `["Error"]`
-     * expression.
-     *
-     * **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.
-     *
-     * @category Symbol Expression
-     *
-     */
-    readonly isValid: boolean;
-    /**
-     * An exact value is not further transformed when evaluated. To get an
-     * approximate evaluation of an exact value, use `.N()`.
-     *
-     * Exact numbers are:
-     * - rationals (including integers)
-     * - complex numbers with integer real and imaginary parts (Gaussian integers)
-     * - square root of rationals
-     *
-     * Non-exact values includes:
-     * - numbers with a fractional part
-     * - complex numbers with a real or imaginary fractional part
-     *
-     */
-    readonly isExact: 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.
-     */
-    readonly isPure: 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 this is a function expressin, a definition is associated with the
-     * canonical expression.
-     *
-     * When determining the canonical form the following function definition
-     * flags are applied:
-     * - `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 his expression is already canonical, the value of canonical is
-     * `this`.
-     *
-     */
-    get canonical(): BoxedExpression;
-    /**
-     * Replace all the symbols in the expression as indicated.
-     *
-     * 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.
-     *
-     */
-    subs(sub: Substitution, options?: {
-        canonical?: boolean;
-    }): BoxedExpression;
-    /**
-     * Transform the expression by applying the rules:
-     * if an expression matches the `match` pattern, replace it with
-     * the `replace` pattern.
-     *
-     * If no rules apply, return `null`.
-     *
-     * See also `subs` for a simple substitution.
-     *
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    replace(rules: BoxedRuleSet | Rule | Rule[], 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.
-     */
-    has(v: string | string[]): boolean;
-    /** Structural/symbolic equality (weak equality).
-     *
-     * `ce.parse('1+x').isSame(ce.parse('x+1'))` is `false`
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * @category Relational Operator
-     */
-    isSame(rhs: BoxedExpression): boolean;
-    /**
-     * If this expression matches `pattern`, return a substitution that makes
-     * `pattern` equal to `this`. Otherwise return `null`.
-     *
-     * If `pattern` includes wildcards (identifiers that starts
-     * with `_`), the substitution will include a prop for each matching named
-     * wildcard.
-     *
-     * If this expression matches `pattern` but there are no named wildcards,
-     * return the empty substitution, `{}`.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     */
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
-    /**
-     * "Not a Number".
-     *
-     * 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
-     *
-     */
-    readonly isNaN: boolean | undefined;
-    /**
-     * The numeric value of this expression is 0.
-     *
-     * @category Expression Properties
-     */
-    readonly isZero: boolean | undefined;
-    /**
-     * The numeric value of this expression is not 0.
-     * @category Expression Properties
-     */
-    readonly isNotZero: boolean | undefined;
-    /**
-     * The numeric value of this expression is not 1.
-     * @category Expression Properties
-     */
-    readonly isOne: boolean | undefined;
-    /**
-     * The numeric value of this expression is not -1.
-     * @category Expression Properties
-     */
-    readonly isNegativeOne: boolean | undefined;
-    /** The numeric value of this expression is ±Infinity or Complex Infinity
-     *
-     * @category Expression Properties
-     */
-    readonly isInfinity: boolean | undefined;
-    /** This expression is a number, but not ±Infinity and not `NaN`
-     *
-     * @category Expression Properties
-     */
-    readonly isFinite: boolean | undefined;
-    /**
-     * @category Expression Properties
-     */
-    readonly isEven: boolean | undefined;
-    /**
-     * @category Expression Properties
-     */
-    readonly isOdd: boolean | undefined;
-    /**
-     * @category Expression Properties
-     */
-    readonly isPrime: boolean | undefined;
-    /**
-     * @category Expression Properties
-     */
-    readonly isComposite: boolean | undefined;
-    /**
-     * Return the value of this expression, if a number literal.
-     *
-     * Note it is possible for `numericValue` to be `null`, and for `isNotZero`
-     * to be true. For example, when a symbol has been defined with an assumption.
-     *
-     * Conversely, `isNumber` may be true even if `numericValue` is `null`,
-     * example the symbol `Pi` return true for `isNumber` but `numericValue` is
-     * `null`. It's value can be accessed with `.value.numericValue`
-     *
-     * @category Numeric Expression
-     *
-     */
-    readonly numericValue: number | Decimal | Complex | Rational | null;
-    /** The shape describes the axis of the expression.
-     * When the expression is a scalar (number), the shape is `[]`.
-     * When the expression is a vector, the shape is `[n]`.
-     * When the expression is a matrix, the shape is `[n, m]`.
-     */
-    readonly shape: number[];
-    /** Return 0 for a scalar, 1 for a vector, 2 for a matrix, > 2 for a multidimensional matrix. It's the length of `expr.shape` */
-    readonly rank: number;
-    /**
-     * 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 `this.sgn`
-     * will return `1` if `isPositive` is `true`, even if this expression has
-     * no value
-     *
-     * @category Numeric Expression
-     *
-     */
-    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 numeric value of this expression is > 0, same as `isGreater(0)`
-     *
-     * @category Expression Properties
-     */
-    readonly isPositive: boolean | undefined;
-    /** The numeric value of this expression is >= 0, same as `isGreaterEqual(0)`
-     *
-     * @category Expression Properties
-     */
-    readonly isNonNegative: boolean | undefined;
-    /** The numeric value of this expression is < 0, same as `isLess(0)`
-     *
-     * @category Expression Properties
-     */
-    readonly isNegative: boolean | undefined;
-    /** The numeric value of this expression is &lt;= 0, same as `isLessEqual(0)`
-     *
-     * @category Expression Properties
-     */
-    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.
-     */
-    readonly wikidata: string | undefined;
-    /** An optional short description if a symbol or function expression.
-     *
-     * 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.
-     */
-    readonly complexity: number | undefined;
-    /**
-     * For symbols and functions, a possible definition associated with the
-     *  expression. `baseDefinition` is the base class of symbol and function
-     *  definition.
-     *
-     * **Note** `undefined` if not a canonical expression.
-     *
-     */
-    readonly baseDefinition: BoxedBaseDefinition | undefined;
-    /**
-     * For functions, a possible definition associated with the expression.
-     *
-     * **Note** `undefined` if not a canonical expression or not a function.
-     *
-     */
-    readonly functionDefinition: BoxedFunctionDefinition | undefined;
-    /**
-     * For symbols, a possible definition associated with the expression.
-     *
-     * **Note** `undefined` if not a symbol
-     *
-     */
-    readonly symbolDefinition: BoxedSymbolDefinition | undefined;
-    /**
-     *
-     * Infer the domain of this expression.
-     *
-     * If the domain of this expression is already known, return `false`.
-     *
-     * If the domain was not set, set it to the inferred domain, return `true`
-     * If the domain was previously inferred, adjust it by widening it,
-     *    return `true`
-     *
-     * @internal
-     */
-    infer(domain: BoxedDomain): boolean;
-    /**
-     * Update the definition associated with this expression, using the
-     * current scope (`ce.context`).
-     *
-     * @internal
-     */
-    bind(): void;
-    /**
-     *
-     * Reset the cached value associated with this expression.
-     *
-     * Use when the environment has changed, for example the numeric mode
-     * or precision, to force the expression to be re-evaluated.
-     *
-     * @internal
-     */
-    reset(): void;
-    /**
-     * Return a simpler form of the canonical form of this expression.
-     *
-     * A series of rewriting rules are applied repeatedly, until no more 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 decimal numbers (numbers that are not
-     * integers) 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 the canonical form of this expression.
-     *
-     * 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 approximate calculations on
-     * decimal numbers (non-integer numbers). Constants, rational numbers and
-     * square root of rational numbers are preserved.
-     *
-     * To perform approximate calculations, use `expr.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 numeric approximation of the canonical form of this expression.
-     *
-     * Any necessary calculations, including on decimal numbers (non-integers),
-     * are performed.
-     *
-     * The calculations are performed according to the `numericMode` and
-     * `precision` properties of the `ComputeEngine`.
-     *
-     * To only perform exact calculations, use `this.evaluate()` instead.
-     *
-     * If the function is not numeric, the result of `this.N()` is the same as
-     * `this.evaluate()`.
-     *
-     * The result is in canonical form.
-     */
-    N(options?: NOptions): BoxedExpression;
-    compile(to?: 'javascript', options?: {
-        optimize: ('simplify' | 'evaluate')[];
-    }): ((args: Record<string, any>) => any | undefined) | undefined;
-    solve(vars: Iterable<string>): null | BoxedExpression[];
-    /**
-     * Return a JavaScript primitive representing the value of this expression.
-     *
-     * Equivalent to `expr.N().valueOf()`.
-     *
-     */
-    get value(): number | boolean | string | number[] | undefined;
-    /**
-     * Only the value of variables can be changed (symbols that are not
-     * constants).
-     *
-     * Throws a runtime error if a constant.
-     *
-     * **Note**: If non-canonical, does nothing.
-     *
-     */
-    set value(value: boolean | string | Decimal | Complex | {
-        re: number;
-        im: number;
-    } | {
-        num: number;
-        denom: number;
-    } | number[] | BoxedExpression | number | 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
-     * expression.
-     *
-     * **Note**: if non-canonical or not valid, return `undefined`.
-     *
-     */
-    get domain(): BoxedDomain | undefined;
-    /** Modify the domain of a symbol.
-     *
-     * **Note**: If non-canonical, does nothing.
-     *
-     */
-    set domain(domain: DomainExpression | BoxedDomain | undefined);
-    /** `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;
-    /**
-     * 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.
-     *
-     *
-     * @category Domain Properties
-     *
-     */
-    readonly isAlgebraic: boolean | undefined;
-    /**
-     * The value of this expression is real number: finite and not imaginary.
-     *
-     * `isFinite && !isImaginary`
-     *
-     *
-     * @category Domain Properties
-     */
-    readonly isReal: boolean | undefined;
-    /** Real or ±Infinity
-     *
-     * `isReal || isInfinity`
-     *
-     *
-     * @category Domain Properties
-     */
-    readonly isExtendedReal: boolean | undefined;
-    /**
-     * The value of this expression is a number, but not `NaN` or any Infinity
-     *
-     * `isReal || isImaginary`
-     *
-     *
-     * @category Domain Properties
-     *
-     */
-    readonly isComplex: boolean | undefined;
-    /** `isReal || isImaginary || isInfinity`
-     *
-     *
-     * @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
-     */
-    isEqual(rhs: BoxedExpression): boolean;
-}
-/** A semi boxed expression is a MathJSON expression which can include some
- * boxed terms.
- *
- * This is convenient when creating new expressions from portions
- * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
- *
- * @category Boxed Expression
- */
-export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
-/**
- * Control how a pattern is matched to an expression.
- *
- * - `substitution`: if present, assumes these values for the named wildcards, and ensure that subsequent occurence of the same wildcard have the same value.
- * - `recursive`: if true, match recursively, otherwise match only the top level.
- * - `numericTolerance`: if present, the tolerance for numeric comparison.
- * - `exact`: if true, only match expressions that are structurally identical. If false, match expressions that are structurally identical or equivalent. For example, when false, `["Add", '_a', 2]` matches `2`, with a value of `_a` of `0`. If true, the expression does not match.
- *
- * @category Pattern Matching
- *
- */
-export type PatternMatchOptions = {
-    substitution?: BoxedSubstitution;
-    recursive?: boolean;
-    numericTolerance?: number;
-    exact?: boolean;
-};
-/**
- * @noInheritDoc
- *
- * @category Pattern Matching
- */
-export type Pattern = BoxedExpression;
-/** @category Assumptions */
-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]>;
-    entries(): IterableIterator<[BoxedExpression, U]>;
-}
+import { FunctionDefinition, SemiBoxedExpression, SymbolDefinition } from './boxed-expression/public';
+export * from './boxed-expression/public';
 /**
  * A table mapping identifiers to their definition.
  *
@@ -1115,760 +36,3 @@ export type IdentifierDefinition = SymbolDefinition | FunctionDefinition | SemiB
 export type IdentifierDefinitions = Readonly<{
     [id: string]: IdentifierDefinition;
 }>;
-/**
- * The entries 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 this type are created as needed.
- *
- * @category Definitions
- */
-export type RuntimeIdentifierDefinitions = Map<string, BoxedSymbolDefinition | BoxedFunctionDefinition>;
-/**
- * A scope is a set of names in a dictionary that are bound (defined) in
- * a MathJSON expression.
- *
- * Scopes are arranged in a stack structure. When an expression that defined
- * a new scope is evaluated, the new scope is added to the scope stack.
- * Outside of the expression, the scope is removed from the scope stack.
- *
- * The scope stack is used to resolve symbols, and it is possible for
- * a scope to 'mask' definitions from previous scopes.
- *
- * Scopes are lexical (also called a static scope): they are defined based on
- * where they are in an expression, they are not determined at runtime.
- *
- * @category Compute Engine
- */
-export type Scope = {
-    /** Signal `timeout` when the execution time for this scope is exceeded.
-     *
-     * Time in seconds, default 2s.
-     *
-     * @experimental
-     */
-    timeLimit: number;
-    /** Signal `out-of-memory` when the memory usage for this scope is exceeded.
-     *
-     * Memory is in Megabytes, default: 1Mb.
-     *
-     * @experimental
-     */
-    memoryLimit: number;
-    /** Signal `recursion-depth-exceeded` when the recursion depth for this
-     * scope is exceeded.
-     *
-     * @experimental
-     */
-    recursionLimit: number;
-    /** Signal `iteration-limit-exceeded` when the iteration limit
-     * in a loop is exceeded. Default: no limits.
-     *
-     * @experimental
-     */
-    iterationLimit: number;
-};
-/** @category Compute Engine */
-export type RuntimeScope = Scope & {
-    parentScope?: RuntimeScope;
-    ids?: RuntimeIdentifierDefinitions;
-    assumptions: undefined | ExpressionMapInterface<boolean>;
-};
-/**
- * @category Definitions
- *
- */
-export type BaseDefinition = {
-    /** 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;
-};
-/**
- * @category Definitions
- *
- */
-export interface 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;
-    /** 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.
- * @category Definitions
- */
-export type FunctionDefinitionFlags = {
-    /**  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]`
-     *
-     * **Default**: `false`
-     */
-    associative: boolean;
-    /** 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`
-     * is constant, is simplified to `["Add", ["f", x], c]`.
-     *
-     * 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`
-     */
-    /** 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
-     * first argument: `["f", ["Multiply", x, y], z]` simplifies to
-     * `["Multiply", ["f", x, z], ["f", y, z]]`
-     *
-     * **Default**: `false`
-     */
-    /** 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
-     * `["Multiply", ["f", x, z], ["f", y, z]]`
-     *
-     * Default: `false`
-     */
-    /** If `true`, `["f", ["f", x]]` simplifies to `["f", x]`.
-     *
-     * **Default**: `false`
-     */
-    idempotent: boolean;
-    /** 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
-     * 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;
-    /**
-     * 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.
-     *
-     * **Default:** false
-     */
-    inert: boolean;
-    /**
-     * All the arguments of a numeric function are numeric,
-     * and its value is numeric.
-     */
-    numeric: boolean;
-};
-/**
- * @category Definitions
- *
- */
-export type FunctionSignature = {
-    /** The domain of this signature, a domain compatible with the `Functions`
-     * domain).
-     *
-     * @deprecated Use params, optParams, restParam and result instead
-     */
-    domain?: DomainExpression;
-    params?: DomainExpression[];
-    optParams?: DomainExpression[];
-    restParam?: DomainExpression;
-    /** The domain of the result of the function. Either a domain
-     * expression, or a function that returns a boxed domain.
-     */
-    result?: DomainExpression | ((ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null | undefined);
-    /**
-     * Return the canonical form of the expression with the arguments `args`.
-     *
-     * The arguments (`args`) may not be in canonical form. If necessary, they
-     * can be put in canonical form.
-     *
-     * This handler should validate the domain and number of the arguments.
-     *
-     * If a required argument is missing, it should be indicated with a
-     * `["Error", "'missing"]` expression. If more arguments than expected
-     * are present, this should be indicated with an
-     * ["Error", "'unexpected-argument'"]` error expression
-     *
-     * If the domain of an argument is not compatible, it should be indicated
-     * with an `incompatible-domain` error.
-     *
-     * `["Sequence"]` expressions are not folded and need to be handled
-     *  explicitly.
-     *
-     * If the function is associative, idempotent or an involution,
-     * this handler should account for it. 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 exact and literal (i.e.
-     * `arg.numericValue !== null && arg.isExact`).
-     *
-     * Values of symbols should not be substituted, unless they have
-     * a `holdUntil` attribute of `"never"`.
-     *
-     * The handler should not consider the value or any assumptions about any
-     * of the arguments that are symbols or functions (i.e. `arg.isZero`,
-     * `arg.isInteger`, etc...) since those may change over time.
-     *
-     * The result of the handler should be a canonical expression.
-     *
-     * If the arguments do not match, they should be replaced with an appropriate
-     * `["Error"]` expression. If the expression cannot be put in canonical form,
-     * the handler should return `null`.
-     *
-     */
-    canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | null;
-    /**
-     * Rewrite an expression into a simpler form.
-     *
-     * The arguments are in canonical form and have been simplified.
-     *
-     * The handler can use the values assigned to symbols and the assumptions
-     * about symbols, for example with `arg.numericValue`, `arg.isInteger` or
-     * `arg.isPositive`.
-     *
-     * Even though a symbol may not have a value, there may be some information
-     * about it reflected for example in `this.isZero` or `this.isPrime`.
-     *
-     * The handler should not perform approximate numeric calculations, such
-     * as calculations involving decimal numbers (non-integers). Making exact
-     * calculations on integers or rationals is OK.
-     *
-     * Do not reduce constants with a `holdUntil` attribute of `"N"`
-     * or `"evaluate"`.
-     *
-     * 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`.
-     *
-     */
-    simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    /**
-     * Evaluate a function expression.
-     *
-     * The arguments have been evaluated, except the arguments to which a
-     * `hold` applied.
-     *
-     * It is not necessary to further simplify or evaluate the arguments.
-     *
-     * If performing numerical calculations, if all the arguments are exact,
-     * return an exact expression. If any of the arguments is not exact, that is
-     * if it is a literal decimal (non-integer) number, return an approximation.
-     * In this case, the value may be the same as `expr.N()`.
-     *
-     * When doing an exact calculation:
-     * - do not reduce rational numbers to decimal (floating point approximation)
-     * - do not down convert bignums to machine numbers
-     * - do not reduce square roots of rational numbers
-     * - do not reduce constants with a `holdUntil` attribute of `"N"`
-     *
-     * If the expression cannot be evaluated, due to the values, domains, or
-     * assumptions about its arguments, for example, return `undefined` or
-     * an `["Error"]` expression.
-     */
-    evaluate?: SemiBoxedExpression | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined);
-    /**
-     * Evaluate numerically a function expression.
-     *
-     * The arguments `args` have been simplified and evaluated, numerically
-     * if possible, except the arguments to which a `hold` apply.
-     *
-     * The arguments may be a combination of numbers, symbolic
-     * expressions and other expressions.
-     *
-     * Perform as many calculations as possible, and return the result.
-     *
-     * 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.
-     *
-     * 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.
-     *
-     * Use the value of `ce.numericMode` to determine how to perform
-     * the numeric evaluation.
-     *
-     * Note that regardless of the current value of `ce.numericMode`, the
-     * arguments may be boxed numbers representing machine numbers, bignum
-     * numbers, complex numbers, rationals or big rationals.
-     *
-     * If the numeric mode does not allow complex numbers (the
-     * `engine.numericMode` is not `"complex"` or `"auto"`) and the result of
-     * the evaluation would be a complex number, return `NaN` instead.
-     *
-     * If `ce.numericMode` is `"bignum"` or `"auto"` the evaluation should
-     * be done using bignums.
-     *
-     * Otherwise, `ce.numericMode` is `"machine", the evaluation should be
-     * performed using machine numbers.
-     *
-     * You may perform any necessary computations, including approximate
-     * calculations on floating point numbers.
-     *
-     */
-    N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    /** Dimensional analysis
-     * @experimental
-     */
-    evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
-    /** Return the sign of the function expression. */
-    sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
-    /** Return a compiled (optimized) expression. */
-    compile?: (expr: BoxedExpression) => CompiledExpression;
-};
-/**
- * @category Definitions
- *
- */
-export type BoxedFunctionSignature = {
-    inferredSignature: boolean;
-    params: BoxedDomain[];
-    optParams: BoxedDomain[];
-    restParam?: BoxedDomain;
-    result: BoxedDomain | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedDomain | null | undefined);
-    canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | null;
-    simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    evaluate?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
-    sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
-    compile?: (expr: BoxedExpression) => CompiledExpression;
-};
-/**
- * The handlers are the primitive operations that can be performed on
- * collections.
- *
- * There are two types of collections:
- * - finite collections, such as lists, tuples, sets, matrices, etc...
- *  The `size()` handler of finite collections returns the number of elements
- * - infinite collections, such as sequences, ranges, etc...
- *  The `size()` handler of infinite collections returns `Infinity`
- *  Infinite collections are not indexable, they have no `at()` handler.
- *
- *  @category Definitions
- */
-export type CollectionHandlers = {
-    /** Return an iterator
-     * - start is optional and is a 1-based index.
-     * - if start is not specified, start from index 1
-     * - count is optional and is the number of elements to return
-     * - if count is not specified or negative, return all the elements from start to the endna
-     *
-     * If there is a `keys()` handler, there is no `iterator()` handler.
-     *
-     * @category Definitions
-     */
-    iterator: (expr: BoxedExpression, start?: number, count?: number) => Iterator<BoxedExpression, undefined>;
-    /** Return the element at the specified index.
-     * The first element is `at(1)`, the last element is `at(-1)`.
-     * If the index is &lt;0, return the element at index `size() + index + 1`.
-     * The index can also be a string for example for dictionaries.
-     * If the index is invalid, return `undefined`.
-     */
-    at: (expr: BoxedExpression, index: number | string) => undefined | BoxedExpression;
-    /** Return the number of elements in the collection.
-     * An empty collection has a size of 0.
-     */
-    size: (expr: BoxedExpression) => number;
-    /**
-     * If the collection is indexed by strings, return the valid values
-     * for the index.
-     */
-    keys: (expr: BoxedExpression) => undefined | Iterator<string>;
-    /**
-     * Return the index of the first element that matches the target expression.
-     * The comparison is done using the `target.isEqual()` method.
-     * If the expression is not found, return `undefined`.
-     * If the expression is found, return the index, 1-based.
-     * If the expression is found multiple times, return the index of the first
-     * match.
-     *
-     * From is the starting index for the search. If negative, start from the end
-     * and search backwards.
-     */
-    indexOf: (expr: BoxedExpression, target: BoxedExpression, from?: number) => number | string | undefined;
-};
-/**
- * Definition record for a function.
- * @category Definitions
- *
- */
-export type FunctionDefinition = BaseDefinition & Partial<CollectionHandlers> & 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?: Hold;
-    signature: FunctionSignature;
-};
-/**
- * @category Definitions
- *
- */
-export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHandlers> & FunctionDefinitionFlags & {
-    complexity: number;
-    hold: Hold;
-    signature: BoxedFunctionSignature;
-};
-/**
- * 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.
- *
- * @category Definitions
- */
-export type NumericFlags = {
-    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;
-};
-/**
- * @category Definitions
- *
- */
-export type SymbolAttributes = {
-    /**
-     * If `true` the value of the symbol is constant. The value or domain of
-     * symbols with this attribute set to `true` cannot be changed.
-     *
-     * If `false`, the symbol is a variable.
-     *
-     * **Default**: `false`
-     */
-    constant: boolean;
-    /**
-     * If the symbol has a value, it is held as indicated in the table below.
-     * A green checkmark indicate that the symbol is substituted.
-  
-  <div className="symbols-table">
-  
-  | Operation | `"never"` | `"simplify"` | `"evaluate"` | `"N"` |
-  | :--- | :----- |
-  | `canonical()`|  (X) | | | |
-  | `simplify()` |   (X) | (X) | | |
-  | `evaluate()` |   (X) | (X) | (X) | |
-  | `"N()"` |  (X) | (X)  |  (X) | (X)  |
-  
-  </div>
-  
-    * Some examples:
-    * - `i` has `holdUntil: 'never'`
-    * - `GoldenRatio` has `holdUntil: 'simplify'` (symbolic constant)
-    * - `x` has `holdUntil: 'evaluate'` (variables)
-    * - `Pi` has `holdUntil: 'N'` (special numeric constant)
-    *
-    * **Default:** `evaluate`
-    */
-    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
-};
-/**
- * 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 = TranscendentalNumbers)
- * @category Definitions
- */
-export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
-    domain?: DomainLiteral | BoxedDomain;
-    /** If true, the domain is inferred, and could be adjusted later
-     * as more information becomes available or if the symbol is explicitly
-     * declared.
-     */
-    inferred?: boolean;
-    /** `value` can be a JS function since for some constants, such as
-     * `Pi`, the actual value depends on the `precision` setting of the
-     * `ComputeEngine` and possible other environment settings */
-    value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    flags?: Partial<NumericFlags>;
-};
-/**
- * @noInheritDoc
- * @category Definitions
- */
-export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<NumericFlags> {
-    get value(): BoxedExpression | undefined;
-    set value(val: SemiBoxedExpression | number | undefined);
-    domain: BoxedDomain | undefined;
-    inferredDomain: boolean;
-}
-/** @category Assumptions */
-export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
-/** @category Compiling */
-export type CompiledExpression = {
-    evaluate?: (scope: {
-        [symbol: string]: BoxedExpression;
-    }) => number | BoxedExpression;
-};
-/** @internal */
-export interface ComputeEngineStats {
-    symbols: Set<BoxedExpression>;
-    expressions: null | Set<BoxedExpression>;
-    highwaterMark: number;
-}
-/** @category Compute Engine */
-export type AssignValue = boolean | number | string | Decimal | Complex | LatexString | SemiBoxedExpression | ((ce: IComputeEngine, args: any) => BoxedExpression) | undefined;
-/** @category Compute Engine */
-export type ArrayValue = boolean | number | string | Decimal | Complex | BoxedExpression | undefined;
-/** @internal */
-export interface IComputeEngine {
-    latexDictionary: readonly LatexDictionaryEntry[];
-    readonly Anything: BoxedDomain;
-    readonly Void: BoxedDomain;
-    readonly Strings: BoxedDomain;
-    readonly Booleans: BoxedDomain;
-    readonly Numbers: BoxedDomain;
-    readonly True: BoxedExpression;
-    readonly False: BoxedExpression;
-    readonly Pi: BoxedExpression;
-    readonly E: BoxedExpression;
-    readonly Nothing: BoxedExpression;
-    readonly Zero: BoxedExpression;
-    readonly One: BoxedExpression;
-    readonly Half: BoxedExpression;
-    readonly NegativeOne: BoxedExpression;
-    readonly I: BoxedExpression;
-    readonly NaN: BoxedExpression;
-    readonly PositiveInfinity: BoxedExpression;
-    readonly NegativeInfinity: BoxedExpression;
-    readonly ComplexInfinity: BoxedExpression;
-    /** @internal */
-    readonly _BIGNUM_NAN: Decimal;
-    /** @internal */
-    readonly _BIGNUM_ZERO: Decimal;
-    /** @internal */
-    readonly _BIGNUM_ONE: Decimal;
-    /** @internal */
-    readonly _BIGNUM_TWO: Decimal;
-    /** @internal */
-    readonly _BIGNUM_HALF: Decimal;
-    /** @internal */
-    readonly _BIGNUM_PI: Decimal;
-    /** @internal */
-    readonly _BIGNUM_NEGATIVE_ONE: Decimal;
-    /** The current scope */
-    context: RuntimeScope | null;
-    /** Absolute time beyond which evaluation should not proceed
-     * @internal
-     */
-    deadline?: number;
-    /** @hidden */
-    readonly timeLimit: number;
-    /** @hidden */
-    readonly iterationLimit: number;
-    /** @hidden */
-    readonly recursionLimit: number;
-    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;
-    bignum: (a: Decimal.Value | bigint) => Decimal;
-    isBignum(a: unknown): a is Decimal;
-    complex: (a: number | Complex, b?: number) => Complex;
-    isComplex(a: unknown): a is Complex;
-    set precision(p: number | 'machine');
-    get precision(): number;
-    costFunction: (expr: BoxedExpression) => number;
-    strict: boolean;
-    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
-    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
-    }): BoxedExpression;
-    function(head: string | BoxedExpression, ops: SemiBoxedExpression[], options?: {
-        metadata?: Metadata;
-        canonical?: boolean;
-    }): BoxedExpression;
-    number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
-        metadata?: Metadata;
-        canonical?: boolean;
-    }): BoxedExpression;
-    symbol(sym: string, options?: {
-        metadata?: Metadata;
-        canonical?: boolean;
-    }): BoxedExpression;
-    string(s: string, metadata?: Metadata): BoxedExpression;
-    domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
-    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
-    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
-    hold(expr: SemiBoxedExpression): BoxedExpression;
-    add(...ops: BoxedExpression[]): BoxedExpression;
-    mul(...ops: BoxedExpression[]): BoxedExpression;
-    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression): BoxedExpression;
-    sqrt(base: BoxedExpression): BoxedExpression;
-    inv(expr: BoxedExpression): BoxedExpression;
-    neg(expr: BoxedExpression): BoxedExpression;
-    div(num: BoxedExpression, denom: BoxedExpression): BoxedExpression;
-    pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    tuple(elements: number[], metadata?: Metadata): BoxedExpression;
-    tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
-    rules(rules: Rule[]): BoxedRuleSet;
-    /**
-     * This is a primitive to create a boxed function.
-     *
-     * In general, consider using `ce.box()` or `canonicalXXX()` instead.
-     *
-     * The caller must ensure that the arguments are in canonical form:
-     * - arguments are `canonical()`
-     * - arguments are sorted
-     * - arguments are flattened and desequenced
-     *
-     * @internal
-     */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    parse(s: LatexString | string, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
-    }): BoxedExpression;
-    parse(s: null, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
-    }): null;
-    parse(s: LatexString | string | null, options?: {
-        canonical?: boolean | CanonicalForm | CanonicalForm[];
-    }): null | BoxedExpression;
-    serialize(expr: SemiBoxedExpression, options?: {
-        canonical?: boolean;
-    }): LatexString;
-    get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
-    set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
-    get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
-    set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
-    pushScope(scope?: Partial<Scope>): IComputeEngine;
-    popScope(): IComputeEngine;
-    swapScope(scope: RuntimeScope | null): RuntimeScope | null;
-    resetContext(): void;
-    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
-    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
-    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
-    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
-    assign(ids: {
-        [id: string]: AssignValue;
-    }): IComputeEngine;
-    assign(id: string, value: AssignValue): IComputeEngine;
-    assign(arg1: string | {
-        [id: string]: AssignValue;
-    }, arg2?: AssignValue): IComputeEngine;
-    declare(identifiers: {
-        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
-    }): IComputeEngine;
-    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
-    declare(arg1: string | {
-        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
-    }, arg2?: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
-    assume(predicate: SemiBoxedExpression): AssumeResult;
-    forget(symbol?: string | string[]): void;
-    get assumptions(): ExpressionMapInterface<boolean>;
-    ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
-    verify(query: SemiBoxedExpression): boolean;
-    /** @internal */
-    shouldContinueExecution(): boolean;
-    /** @internal */
-    checkContinueExecution(): void;
-    /** @internal */
-    cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
-    /** @internal */
-    readonly stats: ComputeEngineStats;
-    /** @internal */
-    reset(): void;
-    /** @internal */
-    _register(expr: BoxedExpression): void;
-    /** @internal */
-    _unregister(expr: BoxedExpression): void;
-}