@cortex-js/compute-engine 0.25.1 → 0.26.2

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

@@ -1,10 +1,141 @@
-/* 0.25.1 */
-import Decimal from 'decimal.js';
-import { Expression, MathJsonNumber, MathJsonString, MathJsonSymbol, MathJsonFunction, MathJsonDictionary, MathJsonIdentifier } from '../../math-json';
+/* 0.26.2 */
+import type { Expression, MathJsonNumber, MathJsonString, MathJsonSymbol, MathJsonFunction, MathJsonIdentifier } from '../../math-json';
 import type { SerializeLatexOptions, LatexDictionaryEntry, ParseLatexOptions } from '../latex-syntax/public';
-import { IndexedLatexDictionary } from '../latex-syntax/dictionary/definitions';
+import type { IndexedLatexDictionary } from '../latex-syntax/dictionary/definitions';
 import { Rational } from '../numerics/rationals';
-import './serialize';
+import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/public';
+import { BigNum, IBigNum } from '../numerics/bignum';
+import { Type, TypeString } from '../../common/type/types';
+import { AbstractTensor } from '../tensor/tensors';
+import { OneOf } from '../../common/one-of';
+/**
+ * :::info[THEORY OF OPERATIONS]
+ *
+ * To create a boxed expression:
+ *
+ * ### `ce.box()` and `ce.parse()`
+ *
+ * Use `ce.box()` or `ce.parse()` to get a canonical expression.
+ *    - the arguments are put in canonical form
+ *    - invisible operators are made explicit
+ *    - a limited number of core simplifications are applied,
+ *      for example 0 is removed from additions
+ *    - sequences are flattened: `["Add", 1, ["Sequence", 2, 3]]` is
+ *      transformed to `["Add", 1, 2, 3]`
+ *    - associative functions are flattened: `["Add", 1, ["Add", 2, 3]]` is
+ *      transformed to `["Add", 1, 2, 3]`
+ *    - the arguments of commutative functions are sorted
+ *    - identifiers are **not** replaced with their values
+ *
+ * ### Algebraic methods (expr.add(), expr.mul(), etc...)
+ *
+ * The boxed expression have some algebraic methods,
+ * i.e. `add`, `mul`, `div`, `pow`, etc. These methods are suitable for
+ * internal calculations, although they may be used as part of the public
+ * API as well.
+ *
+ *    - the operation is performed on the canonical version of the expression
+ *
+ *    - the arguments are not evaluated
+ *
+ *    - the canonical handler (of the corresponding operation) is not called
+ *
+ *    - some additional simplifications over canonicalization are applied.
+ *      For example number literals are combined.
+ *      However, the result is exact, and no approximation is made. Use `.N()`
+ *      to get an approximate value.
+ *      This is equivalent to calling `simplify()` on the expression (but
+ *      without simplifying the arguments).
+ *
+ *    - sequences were already flattened as part of the canonicalization process
+ *
+ *   For 'add' and 'mul', which take multiple arguments, separate functions
+ *   are provided that take an array of arguments. They are equivalent
+ *   to calling the boxed algebraic method, i.e. `ce.Zero.add(1, 2, 3)` and
+ *   `add(1, 2, 3)` are equivalent.
+ *
+ * These methods are not equivalent to calling `expr.evaluate()` on the
+ * expression: evaluate will replace identifiers with their values, and
+ * evaluate the expression
+ *
+ * ### `ce._fn()`
+ *
+ * Use `ce._fn()` to create a new function expression.
+ *
+ * This is a low level method which is typically invoked in the canonical
+ * handler of a function definition.
+ *
+ * The arguments are not modified. The expression is not put in canonical
+ * form. The canonical handler is *not* called.
+ *
+ * A canonical flag can be set when calling the function, but it only
+ * asserts that the function and its arguments are canonical. The caller
+ * is responsible for ensuring that is the case.
+ *
+ *
+ * ### `ce.function()`
+ *
+ * This is a specialized version of `ce.box()`. It is used to create a new
+ * function expression.
+ *
+ * The arguments are put in canonical form and the canonical handler is called.
+ *
+ * For algebraic functions (add, mul, etc..), use the corresponding
+ * canonicalization function, i.e. `canonicalAdd(a, b)` instead of
+ * `ce.function('Add', a, b)`.
+ *
+ * Another option is to use the algebraic methods directly, i.e. `a.add(b)`
+ * instead of `ce.function('Add', a, b)`. However, the algebraic methods will
+ * apply further simplifications which may or may not be desirable. For
+ * example, number literals will be combined.
+ *
+ * ### Canonical Handlers
+ *
+ * Canonical handlers are responsible for:
+ *    - validating the signature (type and number of arguments)
+ *    - flattening sequences
+ *    - flattening associative functions
+ *    - sort the arguments (if the function is commutative)
+ *    - calling `ce._fn()` to create a new function expression
+ *    - if the function definition has a hold, they should also put
+ *      their arguments in canonical form, if appropriate
+ *
+ * When the canonical handler is invoked, the arguments have been put in
+ * canonical form according to the `hold` flag.
+ *
+ * Some canonical handlers are available as separate functions and can be
+ * used directly, for example `canonicalAdd(a, b)` instead of
+ * `ce.function('Add', [a, b])`.
+ *
+ * :::
+ */
+export type Sign = 
+/** The expression is equal to 0 */
+'zero'
+/** The expression is > 0 */
+ | 'positive'
+/** The expression is < 0 */
+ | 'negative'
+/** The expression is >= 0 and isPositive is either false or undefined*/
+ | 'non-negative'
+/** The expression is <= 0 and isNegative is either false or undefined*/
+ | 'non-positive'
+/** The expression is not equal to 0 (possibly with an imaginary part) and isPositive, isNegative, isUnsigned are all false or undefined */
+ | 'not-zero'
+/** The expression has no imaginary part and a non-zero real part and isPositive and isNegative are false or undefined*/
+ | 'real-not-zero'
+/** The expression has no imaginary part and isNotZero,isPositive,isNegative,isNonNegative,isNonPositive,isZero are either false or undefined*/
+ | 'real'
+/** The expression is NaN */
+ | 'nan'
+/** The expression is +∞ */
+ | 'positive-infinity'
+/** The expression is -∞ */
+ | 'negative-infinity'
+/** The expression is ~∞ */
+ | 'complex-infinity'
+/** The expression has an imaginary part or is NaN */
+ | 'unsigned';
 /**
  * :::info[THEORY OF OPERATIONS]
  *
@@ -19,7 +150,8 @@ import './serialize';
  * having to check what kind of instance they are before manipulating them.
  * :::
  *
- * To get a boxed expression, use `ce.box()` or `ce.parse()`.
+ * To get a boxed expression from a LaTeX string use `ce.parse()`, or to
+ * get a boxed expression from a MathJSON expression use `ce.box()`.
  *
  * @category Boxed Expression
  *
@@ -42,11 +174,12 @@ export interface BoxedExpression {
      *
      * @category Primitive Methods
      */
-    valueOf(): number | Object | string | boolean;
+    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`.
+     * for debugging, for example. It is formatted as a ASCIIMath expression.
+     *
+     * To get a LaTeX representation of the expression, use `expr.latex`.
      *
      * Used when coercing a `BoxedExpression` to a `String`.
      *
@@ -60,6 +193,7 @@ export interface BoxedExpression {
      */
     print(): void;
     /** Similar to`expr.valueOf()` but includes a hint.
+     *
      * @category Primitive Methods
      */
     [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
@@ -77,12 +211,15 @@ export interface BoxedExpression {
      * Will ignore any LaTeX metadata.
      */
     toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
+    verbatimLatex?: string;
     /** If `true`, this expression is in a canonical form. */
     get isCanonical(): boolean;
     /** For internal use only, set when a canonical expression is created.
      * @internal
      */
     set isCanonical(val: boolean);
+    /** If `true`, this expression is in a structural form. */
+    get isStructural(): boolean;
     /** MathJSON representation of this expression.
      *
      * This representation always use shorthands when possible. Metadata is not
@@ -93,7 +230,7 @@ export interface BoxedExpression {
      * The expression is represented exactly and no sugaring is applied. For
      * example, `["Power", "x", 2]` is not represented as `["Square", "x"]`.
      *
-     * For more control over the serialization, use `ce.serialize()`.
+     * For more control over the serialization, use `expr.toMathJson()`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -103,15 +240,19 @@ export interface BoxedExpression {
     readonly json: Expression;
     /**
      * The scope in which this expression has been defined.
-     * Is null when the expression is not canonical.
+     *
+     * Is `null` when the expression is not canonical.
      */
     readonly scope: RuntimeScope | null;
-    /** From `Object.is()`. Equivalent to `BoxedExpression.isSame()`
+    /**
+     * Equivalent to `BoxedExpression.isSame()` but the argument can be
+     * a JavaScript primitive. For example, `expr.is(2)` is equivalent to
+     * `expr.isSame(ce.number(2))`.
      *
      * @category Primitive Methods
      *
      */
-    is(rhs: unknown): boolean;
+    is(rhs: any): boolean;
     /** @internal */
     readonly hash: number;
     /** LaTeX representation of this expression.
@@ -119,7 +260,7 @@ export interface BoxedExpression {
      * If the expression was parsed from LaTeX, the LaTeX representation is
      * the same as the input LaTeX.
      *
-     * Otherwise, the serialization can be customized with `ComputeEngine.latexOptions`
+     * To customize the serialization, use `expr.toLatex()`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -141,11 +282,16 @@ export interface BoxedExpression {
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
      * :::
-  
-    * @category Symbol Expression
+     *
+     * @category Symbol Expression
      *
      */
     readonly symbol: string | null;
+    /**
+     * @category Symbol Expression
+     *
+     */
+    readonly tensor: null | AbstractTensor<'expression'>;
     /** If this expression is a string, return the value of the string.
      * Otherwise, return `null`.
      *
@@ -157,14 +303,14 @@ export interface BoxedExpression {
      *
      */
     readonly string: string | null;
-    /** All the subexpressions matching the head
+    /** All the subexpressions matching the named operator, recursively.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
      * :::
      *
      */
-    getSubexpressions(head: string): ReadonlyArray<BoxedExpression>;
+    getSubexpressions(name: string): ReadonlyArray<BoxedExpression>;
     /** All the subexpressions in this expression, recursively
      *
      * :::info[Note]
@@ -195,7 +341,10 @@ export interface BoxedExpression {
      *
      */
     readonly freeVariables: ReadonlyArray<string>;
-    /** All the `["Error"]` subexpressions
+    /** All the `["Error"]` subexpressions.
+     *
+     * If an expression includes an error, the expression is also an error.
+     * In that case, the `this.isValid` property is `false`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -203,22 +352,34 @@ export interface BoxedExpression {
      *
      */
     readonly errors: ReadonlyArray<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.
+    /** `true` if this expression or any of its subexpressions is an `["Error"]`
+     * expression.
      *
      * :::info[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, 7]`.
+     * 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 type
+     * mismatch, or missing or unexpected arguments.
      * :::
-  
-    */
-    readonly head: BoxedExpression | string;
-    /** The list of arguments of the function, its "tail".
+     *
+     * @category Symbol Expression
+     *
+     */
+    readonly isValid: boolean;
+    /**
+     * The name of the operator of the expression.
+     *
+     * For example, the name of the operator of `["Add", 2, 3]` is `"Add"`.
+     *
+     * A string literal has a `"String"` operator.
+     *
+     * A symbol has a `"Symbol"` operator.
+     *
+     * A number has a `"Number"`, `"Real"`, `"Rational"` or `"Integer"` operator.
+     *
+     */
+    readonly operator: string;
+    /** The list of operands of the function.
      *
      * If the expression is not a function, return `null`.
      *
@@ -243,7 +404,9 @@ export interface BoxedExpression {
      *
      */
     readonly nops: number;
-    /** First operand, i.e.`this.ops[0]`
+    /** First operand, i.e.`this.ops[0]`.
+     *
+     * If there is no first operand, return the symbol `Nothing`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -255,6 +418,8 @@ export interface BoxedExpression {
      */
     readonly op1: BoxedExpression;
     /** Second operand, i.e.`this.ops[1]`
+     *
+     * If there is no second operand, return the symbol `Nothing`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -266,6 +431,8 @@ export interface BoxedExpression {
      */
     readonly op2: BoxedExpression;
     /** Third operand, i.e. `this.ops[2]`
+     *
+     * If there is no third operand, return the symbol `Nothing`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -276,37 +443,9 @@ export interface BoxedExpression {
      *
      */
     readonly op3: BoxedExpression;
-    /** `true` if this expression or any of its subexpressions is an `["Error"]`
-     * expression.
-     *
-     * :::info[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.
      *
@@ -320,7 +459,17 @@ export interface BoxedExpression {
      * :::
      */
     readonly isPure: boolean;
-    /** True if the expression is a constant, that is a symbol with an immutable value */
+    /**
+     * True if the the value of the expression does not depend on the value of
+     * any other expression.
+     *
+     * For example, a number literal, a symbol with a constant value.
+     * - `2` is constant
+     * - `Pi` is constant
+     * - `["Add", "Pi", 2]` is constant
+     * - `x` is not constant
+     * - `["Add", "x", 2]` is not constant
+     */
     readonly isConstant: boolean;
     /**
      * Return the canonical form of this expression.
@@ -340,11 +489,31 @@ export interface BoxedExpression {
      *
      */
     get canonical(): BoxedExpression;
+    /**
+     * Return the structural form of this expression.
+     *
+     * Some expressions, such as rational numbers, are represented with
+     * a `BoxedExpression` object. In some cases, for example when doing a
+     * structural comparison of two expressions, it is useful to have a
+     * structural representation of the expression where the rational numbers
+     * is represented by a function expression instead.
+     *
+     * If there is a structural representation of the expression, return it,
+     * otherwise return `this`.
+     *
+     */
+    get structural(): 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.
+     * using `this.subs()` is more efficient, and simpler, but limited
+     * to replacing symbols.
+     *
+     * The result is bound to the current scope, not to `this.scope`.
+     *
+     * If `options.canonical` is not set, the result is canonical if `this`
+     * is canonical.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -355,38 +524,42 @@ export interface BoxedExpression {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
     /**
-     * Recursively replace all the terms in the expression as indicated.
+     * Recursively replace all the subexpressions in the expression as indicated.
      *
-     * To remove a subexpression, return an empty Sequence expression.
+     * To remove a subexpression, return an empty `["Sequence"]` expression.
      *
      * The canonical option is applied to each function subexpression after
      * the substitution is applied.
      *
-     * **Default**: `{canonical: true, recursive: true}`
+     * If no `options.canonical` is set, the result is canonical if `this`
+     * is canonical.
+     *
+     * **Default**: `{ canonical: this.isCanonical, recursive: true }`
      */
     map(fn: (expr: BoxedExpression) => BoxedExpression, options?: {
         canonical: CanonicalOptions;
         recursive?: boolean;
     }): BoxedExpression;
     /**
-     * Transform the expression by applying the rules:
+     * Transform the expression by applying one or more replacement rules:
      *
-     * If the expression matches the `match` pattern, replace it with
-     * the `replace` pattern.
+     * - If the expression matches the `match` pattern and the `condition`
+     *  predicate is true, replace it with the `replace` pattern.
      *
-     * If no rules apply, return `null`.
+     * - If no rules apply, return `null`.
      *
-     * See also `subs` for a simple substitution.
+     * See also `expr.subs()` for a simple substitution of symbols.
      *
+     * If `options.canonical` is not set, the result is canonical if `this`
+     * is canonical.
      *
      * :::info[Note]
-     * Applicable to canonical and non-canonical expressions. If the
-     * expression is non-canonical, the result is also non-canonical.
+     * Applicable to canonical and non-canonical expressions.
      * :::
      */
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): null | BoxedExpression;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): null | BoxedExpression;
     /**
-     * True if the expression includes a symbol `v` or a function head `v`.
+     * True if the expression includes a symbol `v` or a function operator `v`.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -395,7 +568,9 @@ export interface BoxedExpression {
     has(v: string | string[]): boolean;
     /** Structural/symbolic equality (weak equality).
      *
-     * `ce.parse('1+x').isSame(ce.parse('x+1'))` is `false`
+     * `ce.parse('1+x').isSame(ce.parse('x+1'))` is `false`.
+     *
+     * See `expr.isEqual()` for mathematical equality.
      *
      * :::info[Note]
      * Applicable to canonical and non-canonical expressions.
@@ -404,6 +579,12 @@ export interface BoxedExpression {
      * @category Relational Operator
      */
     isSame(rhs: BoxedExpression): boolean;
+    /**
+     * Return this expression expressed as a numerator and denominator.
+     */
+    get numerator(): BoxedExpression;
+    get denominator(): BoxedExpression;
+    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
     /**
      * If this expression matches `pattern`, return a substitution that makes
      * `pattern` equal to `this`. Otherwise return `null`.
@@ -422,7 +603,7 @@ export interface BoxedExpression {
      * :::
      *
      */
-    match(pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     /**
      * "Not a Number".
      *
@@ -437,119 +618,199 @@ export interface BoxedExpression {
      */
     readonly isNaN: boolean | undefined;
     /**
-     * The numeric value of this expression is 0.
+     * The numeric value of this expression is `±Infinity` or Complex Infinity
      *
      * @category Numeric Expression
      */
-    readonly isZero: boolean | undefined;
-    /**
-     * The numeric value of this expression is not 0.
+    readonly isInfinity: boolean | undefined;
+    /** This expression is a number, but not `±Infinity`, 'ComplexInfinity` or
+     *  `NaN`
+     *
      * @category Numeric Expression
      */
-    readonly isNotZero: boolean | undefined;
+    readonly isFinite: boolean | undefined;
     /**
-     * The numeric value of this expression is not 1.
      * @category Numeric Expression
      */
-    readonly isOne: boolean | undefined;
+    readonly isEven: boolean | undefined;
     /**
-     * The numeric value of this expression is not -1.
      * @category Numeric Expression
      */
-    readonly isNegativeOne: boolean | undefined;
-    /** The numeric value of this expression is ±Infinity or Complex Infinity
+    readonly isOdd: boolean | undefined;
+    /**
+     * Return the value of this expression, if a number literal.
+     *
+     * Note it is possible for `this.numericValue` to be `null`, and for
+     * `this.isNotZero` to be true. For example, when a symbol has been
+     * defined with an assumption.
+     *
+     * Conversely, `this.isNumber` may be true even if `numericValue` is `null`,
+     * example the symbol `Pi` return `true` for `isNumber` but `numericValue` is
+     * `null`. Its value can be accessed with `.N().numericValue`.
+     *
+     * To check if an expression is a number literal, use `this.isNumberLiteral`.
+     * If `this.isNumberLiteral` is `true`, `this.numericValue` is not `null`
      *
      * @category Numeric Expression
+     *
      */
-    readonly isInfinity: boolean | undefined;
-    /** This expression is a number, but not ±Infinity and not `NaN`
+    readonly numericValue: number | NumericValue | null;
+    /**
+     * Return `true` if this expression is a number literal, for example
+     * `2`, `3.14`, `1/2`, `√2` etc.
+     *
+     * This is equivalent to checking if `this.numericValue` is not `null`.
      *
      * @category Numeric Expression
+     *
      */
-    readonly isFinite: boolean | undefined;
+    readonly isNumberLiteral: boolean;
     /**
-     * @category Numeric Expression
+     * Return `true` if this expression is a function expression.
+     *
+     * If `true`, `this.ops` is not `null`, and `this.operator` is the name
+     * of the function.
      */
-    readonly isEven: boolean | undefined;
+    readonly isFunctionExpression: boolean;
     /**
+     * If this expression is a number literal or a symbol with a value that
+     * is a number literal, return the real part of the value.
+     *
+     * If the expression is not a number literal, or a symbol with a value
+     * that is a number literal, return `NaN` (not a number).
+     *
      * @category Numeric Expression
      */
-    readonly isOdd: boolean | undefined;
+    readonly re: number;
     /**
+     * If this expression is a number literal or a symbol with a value that
+     * is a number literal, return the imaginary part of the value. If the value
+     * is a real number, the imaginary part is 0.
+     *
+     * If the expression is not a number literal, or a symbol with a value
+     * that is a number literal, return `NaN` (not a number).
+     *
      * @category Numeric Expression
      */
-    readonly isPrime: boolean | undefined;
+    readonly im: number;
     /**
+     * If this expression is a number literal or a symbol with a value that
+     * is a number literal, return the real part of the value as a `BigNum`.
+     *
+     * If the value is not available as a bignum return `undefined`. That is,
+     * the value is not upconverted to a bignum.
+     *
+     * To get the real value either as a bignum or a number, use
+     * `this.bignumRe ?? this.re`. When using this pattern, the value is
+     * returned as a bignum if available, otherwise as a number or NaN if
+     * the value is not a number literal or a symbol with a value that is a
+     * number literal.
+     *
      * @category Numeric Expression
+     *
      */
-    readonly isComposite: boolean | undefined;
+    readonly bignumRe: BigNum | undefined;
     /**
-     * Return the value of this expression, if a number literal.
+     * If this expression is a number literal, return the imaginary part as a
+     * `BigNum`.
      *
-     * 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.
+     * It may be 0 if the number is real.
      *
-     * Conversely, `isNumber` may be true even if `numericValue` is `null`,
-     * example the symbol `Pi` return true for `isNumber` but `numericValue` is
-     * `null`. Its value can be accessed with `.value.numericValue`
+     * If the expression is not a number literal or the value is not available
+     * as a bignum return `undefined`. That is, the value is not upconverted
+     * to a bignum.
      *
-     * @category Numeric Expression
+     * To get the imaginary value either as a bignum or a number, use
+     * `this.bignumIm ?? this.im`. When using this pattern, the value is
+     * returned as a bignum if available, otherwise as a number or NaN if
+     * the value is not a number literal or a symbol with a value that is a
+     * number literal.
      *
+     * @category Numeric Expression
      */
-    readonly numericValue: number | Decimal | Complex | Rational | null;
-    /** The shape describes the axis of the expression.
+    readonly bignumIm: BigNum | undefined;
+    /**
+     * Attempt to factor a numeric coefficient `c` and a `rest` out of a
+     * canonical expression such that `rest.mul(c)` is equal to `this`.
+     *
+     * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
+     *
+     * For example:
+     *
+     * ['Multiply', 2, 'x', 3, 'a']
+     *    -> [NumericValue(6), ['Multiply', 'x', 'a']]
+     *
+     * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
+     *    -> [NumericValue({rational: [2, 3]}), ['Divide', 'x', ['Multiply, 'y', 'a']]]
+     */
+    toNumericValue(): [NumericValue, BoxedExpression];
+    neg(): BoxedExpression;
+    inv(): BoxedExpression;
+    abs(): BoxedExpression;
+    add(rhs: number | BoxedExpression): BoxedExpression;
+    sub(rhs: BoxedExpression): BoxedExpression;
+    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
+    div(rhs: number | BoxedExpression): BoxedExpression;
+    pow(exp: number | BoxedExpression): BoxedExpression;
+    root(exp: number | BoxedExpression): BoxedExpression;
+    sqrt(): BoxedExpression;
+    ln(base?: number | BoxedExpression): BoxedExpression;
+    /**
+     *
+     * 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]`.
+     *
+     * When the expression is a vector of length `n`, the shape is `[n]`.
+     *
+     * When the expression is a `n` by `m` 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` */
+    /** Return 0 for a scalar, 1 for a vector, 2 for a matrix, > 2 for
+     * a multidimensional matrix.
+     *
+     * The rank is equivalent to 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)
+     * Return the sign of the expression.
      *
      * Note that complex numbers have no natural ordering,
-     * so if the value is a complex number, `sgn` is either 0, or `null`
+     * so if the value is an imaginary number (a complex number with a non-zero
+     * imaginary part), `this.sgn` will return `unsigned`.
      *
      * 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
+     * will return `positive` if the symbol is assumed to be positive
+     * (using `ce.assume()`).
      *
      * @category Numeric Expression
      *
      */
-    readonly sgn: -1 | 0 | 1 | undefined | null;
+    readonly sgn: Sign | undefined;
     /** If the expressions cannot be compared, return `undefined`
      *
      * The numeric value of both expressions are compared.
      *
+     * The expressions are evaluated before being compared, which may be
+     * expensive.
+     *
      * @category Relational Operator
      */
-    isLess(rhs: BoxedExpression): boolean | undefined;
+    isLess(other: number | BoxedExpression): boolean | undefined;
     /**
      * The numeric value of both expressions are compared.
      * @category Relational Operator
      */
-    isLessEqual(rhs: BoxedExpression): boolean | undefined;
+    isLessEqual(other: number | BoxedExpression): boolean | undefined;
     /**
      * The numeric value of both expressions are compared.
      * @category Relational Operator
      */
-    isGreater(rhs: BoxedExpression): boolean | undefined;
+    isGreater(other: number | BoxedExpression): boolean | undefined;
     /**
      * The numeric value of both expressions are compared.
      * @category Relational Operator
      */
-    isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    isGreaterEqual(other: number | BoxedExpression): boolean | undefined;
     /** The numeric value of this expression is > 0, same as `isGreater(0)`
      *
      * @category Numeric Expression
@@ -570,34 +831,6 @@ export interface BoxedExpression {
      * @category Numeric Expression
      */
     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.
      *
      * :::info[Note]
@@ -616,7 +849,7 @@ export interface BoxedExpression {
      */
     readonly description: undefined | string[];
     /** An optional URL pointing to more information about the symbol or
-     *  function head.
+     *  function operator.
      *
      * :::info[Note]
      * `undefined` if not a canonical expression.
@@ -633,8 +866,8 @@ export interface BoxedExpression {
      */
     readonly complexity: number | undefined;
     /**
-     * For symbols and functions, a possible definition associated with the
-     *  expression. `baseDefinition` is the base class of symbol and function
+     * For symbols and functions, a definition associated with the
+     *  expression. `this.baseDefinition` is the base class of symbol and function
      *  definition.
      *
      * :::info[Note]
@@ -644,7 +877,7 @@ export interface BoxedExpression {
      */
     readonly baseDefinition: BoxedBaseDefinition | undefined;
     /**
-     * For functions, a possible definition associated with the expression.
+     * For functions, a definition associated with the expression.
      *
      * :::info[Note]
      * `undefined` if not a canonical expression or not a function.
@@ -653,7 +886,7 @@ export interface BoxedExpression {
      */
     readonly functionDefinition: BoxedFunctionDefinition | undefined;
     /**
-     * For symbols, a possible definition associated with the expression.
+     * For symbols, a definition associated with the expression.
      *
      * Return `undefined` if not a symbol
      *
@@ -661,17 +894,17 @@ export interface BoxedExpression {
     readonly symbolDefinition: BoxedSymbolDefinition | undefined;
     /**
      *
-     * Infer the domain of this expression.
+     * Infer the type of this expression.
      *
-     * If the domain of this expression is already known, return `false`.
+     * If the type 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,
+     * If the type was not set, set it to the inferred type, return `true`
+     * If the type was previously inferred, adjust it by widening it,
      *    return `true`
      *
      * @internal
      */
-    infer(domain: BoxedDomain): boolean;
+    infer(t: Type): boolean;
     /**
      * Update the definition associated with this expression, using the
      * current scope (`ce.context`).
@@ -690,16 +923,13 @@ export interface BoxedExpression {
      */
     reset(): void;
     /**
-     * Return a simpler form of the canonical form of this expression.
+     * Return a simpler 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`.
+     * used, for example `expr.isInteger` or `expr.isPositive`.
      *
      * No calculations involving decimal numbers (numbers that are not
      * integers) are performed but exact calculations may be performed,
@@ -707,10 +937,17 @@ export interface BoxedExpression {
      *
      * \\( \sin(\frac{\pi}{4}) \longrightarrow \frac{\sqrt{2}}{2} \\).
      *
-     * The result is in canonical form.
+     * The result is canonical.
+     *
+     * To manipulate symbolically non-canonical expressions, use `expr.replace()`.
      *
      */
-    simplify(options?: SimplifyOptions): BoxedExpression;
+    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
+    /**
+     * Expand the expression: distribute multiplications over additions,
+     * and expand powers.
+     */
+    expand(): BoxedExpression;
     /**
      * Return the value of the canonical form of this expression.
      *
@@ -724,11 +961,11 @@ export interface BoxedExpression {
      * 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.
+     * The result may be a rational number or the product of a rational number
+     * and the square root of an integer.
      *
-     * To perform approximate calculations, use `expr.N()` instead.
+     * To perform approximate calculations, use `expr.N()` instead,
+     * or set `options.numericApproximation` to `true`.
      *
      * The result of `expr.evaluate()` may be the same as `expr.simplify()`.
      *
@@ -741,8 +978,8 @@ export interface BoxedExpression {
      * 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`.
+     * The calculations are performed according to the
+     * `precision` property of the `ComputeEngine`.
      *
      * To only perform exact calculations, use `this.evaluate()` instead.
      *
@@ -751,10 +988,35 @@ export interface BoxedExpression {
      *
      * The result is in canonical form.
      */
-    N(options?: NOptions): BoxedExpression;
+    N(): BoxedExpression;
+    /**
+     * Compile the expression to a JavaScript function.
+     *
+     * The function takes an object as argument, with the keys being the
+     * symbols in the expression, and returns the value of the expression.
+     *
+     *
+     * ```javascript
+     * const expr = ce.parse('x^2 + y^2');
+     * const f = expr.compile('javascript');
+     * console.log(f({x: 2, y: 3}));
+     * ```
+     */
     compile(to?: 'javascript', options?: {
         optimize: ('simplify' | 'evaluate')[];
     }): ((args: Record<string, any>) => any | undefined) | undefined;
+    /**
+     * If this is an equation, solve the equation for the variables in vars.
+     * Otherwise, solve the equation `this = 0` for the variables in vars.
+     *
+     *
+     * ```javascript
+     * const expr = ce.parse('x^2 + 2*x + 1 = 0');
+     * console.log(expr.solve('x'));
+     * ```
+     *
+     *
+     */
     solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     /**
      * Return a JavaScript primitive representing the value of this expression.
@@ -762,7 +1024,7 @@ export interface BoxedExpression {
      * Equivalent to `expr.N().valueOf()`.
      *
      */
-    get value(): number | boolean | string | Object | undefined;
+    get value(): number | boolean | string | object | undefined;
     /**
      * Only the value of variables can be changed (symbols that are not
      * constants).
@@ -774,7 +1036,7 @@ export interface BoxedExpression {
      * :::
      *
      */
-    set value(value: boolean | string | Decimal | Complex | {
+    set value(value: boolean | string | BigNum | {
         re: number;
         im: number;
     } | {
@@ -783,44 +1045,47 @@ export interface BoxedExpression {
     } | number[] | BoxedExpression | number | undefined);
     /**
      *
-     * The domain of the value of this expression.
+     * The type 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.
-     *
-     * :::info[Note]
-     * If non-canonical or not valid, return `undefined`.
-     * :::
+     * If a function expression, the type of the value of the function
+     * (the result type).
      *
-     */
-    get domain(): BoxedDomain | undefined;
-    /** Modify the domain of a symbol.
+     * If a symbol the type of the value of the symbol.
      *
      * :::info[Note]
-     * If non-canonical does nothing
+     * If not valid, return `"error"`.
+     * If non-canonical, return `undefined`.
+     * If the type is not known, return `"unknown"`.
      * :::
      *
      */
-    set domain(domain: DomainExpression | BoxedDomain | undefined);
+    get type(): Type;
+    set type(type: Type);
     /** `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
+     * If `isNumber` is `true`, this indicates that evaluating the expression
+     * will return a number.
+     *
+     * This does not indicate that the expression is a number literal. To check
+     * if the expression is a number literal, use `expr.isNumberLiteral`.
+     *
+     * For example, the expression `["Add", 1, "x"]` is a number if "x" is a
+     * number and `expr.isNumber` is `true`, but `isNumberLiteral` is `false`.
+     *
+     * @category Type Properties
      */
     readonly isNumber: boolean | undefined;
-    /** The value of this expression is an element of the set ℤ: ...,-2, -1, 0, 1, 2...
+    /**
+     *
+     * The value of this expression is an element of the set ℤ: ...,-2, -1, 0, 1, 2...
      *
+     * Note that ±∞ and NaN are not integers.
      *
-     * @category Domain Properties
+     * @category Type Properties
      *
      */
     readonly isInteger: boolean | undefined;
@@ -828,75 +1093,107 @@ export interface BoxedExpression {
      *
      * Note that every integer is also a rational.
      *
+     * This is equivalent to `this.type === "rational" || this.type === "integer"`
+     *
+     * Note that ±∞ and NaN are not rationals.
      *
-     * @category Domain Properties
+     * @category Type 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.
+     * The value of this expression is a real number.
      *
-     * All integers and rational numbers are algebraic.
+     * This is equivalent to `this.type === "rational" || this.type === "integer" || this.type === "real"`
      *
-     * Transcendental numbers, such as \\( \pi \\) or \\( e \\) are not algebraic.
+     * Note that ±∞ and NaN are not real numbers.
      *
+     * @category Type Properties
+     */
+    readonly isReal: boolean | undefined;
+    /** Mathematical equality (strong equality), that is the value
+     * of this expression and the value of `other` are numerically equal.
      *
-     * @category Domain Properties
+     * Both expressions are evaluated and the result is compared numerically.
      *
-     */
-    readonly isAlgebraic: boolean | undefined;
-    /**
-     * The value of this expression is real number: finite and not imaginary.
+     * 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.
      *
-     * `isFinite && !isImaginary`
+     * The evaluations may be expensive operations. Other options to consider
+     * to compare two expressions include:
+     * - `expr.isSame(other)` for a structural comparison
+     * - `expr.is(other)` for a comparison of a number literal
      *
+     * ## Examples
      *
-     * @category Domain Properties
-     */
-    readonly isReal: boolean | undefined;
-    /** Real or ±Infinity
+     * ```js
+     * let expr = ce.parse('2 + 2');
+     * console.log(expr.isEqual(4)); // true
+     * console.log(expr.isSame(ce.parse(4))); // false
+     * console.log(expr.is(4)); // false
      *
-     * `isReal || isInfinity`
+     * expr = ce.parse('4');
+     * console.log(expr.isEqual(4)); // true
+     * console.log(expr.isSame(ce.parse(4))); // true
+     * console.log(expr.is(4)); // true (fastest)
      *
+     * ```
      *
-     * @category Domain Properties
+     * @category Relational Operator
      */
-    readonly isExtendedReal: boolean | undefined;
+    isEqual(other: number | BoxedExpression): boolean | undefined;
     /**
-     * The value of this expression is a number, but not `NaN` or any Infinity
-     *
-     * `isReal || isImaginary`
+     * Return true if the expression is a collection: a list, a vector, a matrix, a map, a tuple, etc...
+     */
+    isCollection: boolean;
+    /**
+     * If this is a collection, return true if the `rhs` expression is in the
+     * collection.
      *
+     * Return `undefined` if the membership cannot be determined.
+     */
+    contains(rhs: BoxedExpression): boolean | undefined;
+    /**
+     * If this is a collection, return the number of elements in the collection.
      *
-     * @category Domain Properties
+     * If the collection is infinite, return `Infinity`.
      *
      */
-    readonly isComplex: boolean | undefined;
-    /** `isReal || isImaginary || isInfinity`
+    get size(): number;
+    /**
+     * If this is a collection, return an iterator over the elements of the collection.
+     *
+     * If `start` is not specified, start from the first element.
      *
+     * If `count` is not specified or negative, return all the elements from `start` to the end.
      *
-     * @category Domain Properties
+     * ```js
+     * const expr = ce.parse('[1, 2, 3, 4]');
+     * for (const e of expr.each()) {
+     *  console.log(e);
+     * }
+     * ```
      */
-    readonly isExtendedComplex: boolean | undefined;
-    /** The value of this expression is a number with a imaginary part
+    each: (start?: number, count?: number) => Iterator<BoxedExpression, undefined>;
+    /** If this is an indexable collection, return the element at the specified
+     *  index.
      *
+     * If the index is negative, return the element at index `size() + index + 1`.
      *
-     * @category Domain Properties
      */
-    readonly isImaginary: boolean | undefined;
-    /** Mathematical equality (strong equality), that is the value
-     * of this expression and of `rhs` are numerically equal.
+    at(index: number): BoxedExpression | undefined;
+    /** If this is a map or a tuple, return the value of the corresponding key.
      *
-     * The numeric value of both expressions are compared.
+     * If `key` is a `BoxedExpression`, it should be a string.
      *
-     * 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;
+    get(key: string | BoxedExpression): BoxedExpression | undefined;
+    /**
+     * If this is an indexable collection, return the index of the first element
+     * that matches the target expression.
+     */
+    indexOf(expr: BoxedExpression): number | undefined;
 }
 /** A semi boxed expression is a MathJSON expression which can include some
  * boxed terms.
@@ -906,7 +1203,7 @@ export interface BoxedExpression {
  *
  * @category Boxed Expression
  */
-export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
+export type SemiBoxedExpression = number | bigint | string | BigNum | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | readonly [MathJsonIdentifier, ...SemiBoxedExpression[]] | BoxedExpression;
 /**
  * @category Definitions
  *
@@ -922,96 +1219,108 @@ export interface BoxedBaseDefinition {
      * This field is usually undefined, but its value is set by `getDefinition()`
      */
     scope: RuntimeScope | undefined;
+    collection?: Partial<CollectionHandlers>;
     /** When the environment changes, for example the numerical precision,
      * call `reset()` so that any cached values can be recalculated.
      */
-    reset(): any;
+    reset(): void;
 }
 /**
- * Use `contravariant` for the arguments of a function.
- * Use `covariant` for the result of a function.
- * Use `bivariant` to check the domain matches exactly.
+ * These handlers compare two expressions.
  *
- * @category Boxed Expression
- */
-export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
-/** A domain constructor is the head of a domain expression.
+ * If only one of the handlers is provided, the other is derived from it.
  *
- * @category Boxed Expression
+ * Having both may be useful if comparing non-equality is faster than equality.
  *
- */
-export type DomainConstructor = 'FunctionOf' | 'ListOf' | 'DictionaryOf' | 'TupleOf' | 'Intersection' | 'Union' | 'OptArg' | 'VarArg' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
-/**
- * @noInheritDoc
+ *  @category Definitions
  *
- * @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;
-}
+export type EqHandlers = {
+    eq: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+};
 /**
- * The handlers are the primitive operations that can be performed on
+ * These 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.
+ *  Infinite collections are not indexable: they have no `at()` handler.
  *
  *  @category Definitions
  */
 export type CollectionHandlers = {
+    /** Return the number of elements in the collection.
+     *
+     * An empty collection has a size of 0.
+     */
+    size: (collection: BoxedExpression) => number;
+    /**
+     * Return `true` if the target
+     * expression is in the collection, `false` otherwise.
+     */
+    contains: (collection: BoxedExpression, target: BoxedExpression) => boolean;
     /** 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 count is not specified or negative, return all the elements from
+     *   start to the end
      *
      * 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.
+    iterator: (collection: 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.
+     *
+     * The index can also be a string for example for maps. The set of valid keys
+     * is returned by the `keys()` handler.
+     *
      * 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;
+    at: (collection: BoxedExpression, index: number | string) => undefined | BoxedExpression;
     /**
-     * If the collection is indexed by strings, return the valid values
+     * If the collection can be indexed by strings, return the valid values
      * for the index.
      */
-    keys: (expr: BoxedExpression) => undefined | Iterator<string>;
+    keys: (collection: BoxedExpression) => undefined | Iterable<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.
+     * 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;
+    indexOf: (collection: BoxedExpression, target: BoxedExpression, from?: number) => number | undefined;
+    /**
+     * Return `true` if all the elements of `target` are in `expr`.
+     * Both `expr` and `target` are collections.
+     * If strict is `true`, the subset must be strict, that is, `expr` must
+     * have more elements than `target`.
+     */
+    subsetOf: (collection: BoxedExpression, target: BoxedExpression, strict: boolean) => boolean;
+    /** Return the sign of all the elements of the collection. */
+    eltsgn: (collection: BoxedExpression) => Sign | undefined;
+    /** Return the widest type of all the elements in the collection */
+    elttype: (collection: BoxedExpression) => Type | undefined;
 };
 /**
  * A function definition can have some flags to indicate specific
@@ -1019,6 +1328,17 @@ export type CollectionHandlers = {
  * @category Definitions
  */
 export type FunctionDefinitionFlags = {
+    /**
+     * If `true`, the arguments of the functions are held unevaluated.
+     *
+     * It will be up to the `evaluate()` handler to evaluate the arguments as
+     * needed. This is conveninent to pass symbolic expressions as arguments
+     * to functions without having to explicitly use a `Hold` expression.
+     *
+     * This also applies to the `canonical()` handler.
+     *
+     */
+    hold: boolean;
     /**  If `true`, the function is applied element by element to lists, matrices
      * (`["List"]` or `["Tuple"]` expressions) and equations (relational
      * operators).
@@ -1037,25 +1357,15 @@ export type FunctionDefinitionFlags = {
      * **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]`.
+    /**
+     * If `commutative` is `true`, the order of the arguments is determined by
+     * this function.
      *
-     * For example, `Log` is additive.
+     * If the function is not provided, the arguments are ordered by the
+     * default order of the arguments.
      *
-     * **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`
      */
+    commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
     /** If `true`, when the function is univariate, `["f", ["Multiply", x, c]]`
      * simplifies to `["Multiply", ["f", x], c]` where `c` is constant
      *
@@ -1088,19 +1398,6 @@ export type FunctionDefinitionFlags = {
      * **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 Compiling */
 export type CompiledExpression = {
@@ -1108,34 +1405,35 @@ export type CompiledExpression = {
         [symbol: string]: BoxedExpression;
     }) => number | BoxedExpression;
 };
-/**
- * @category Definitions
- *
- */
-export type BoxedFunctionSignature = {
-    inferredSignature: boolean;
-    params: BoxedDomain[];
-    optParams: BoxedDomain[];
-    restParam?: BoxedDomain;
-    result: BoxedDomain | ((ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedDomain | null | undefined);
-    canonical?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedExpression | null;
-    simplify?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
-    evaluate?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
-    N?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
-    evalDimension?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedExpression;
-    sgn?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => -1 | 0 | 1 | undefined;
-    compile?: (expr: BoxedExpression) => CompiledExpression;
-};
 /** @category Definitions */
 export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
 /**
  * @category Definitions
  *
  */
-export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHandlers> & FunctionDefinitionFlags & {
+export type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
     complexity: number;
-    hold: Hold;
-    signature: BoxedFunctionSignature;
+    hold: boolean;
+    inferredSignature: boolean;
+    signature: Type;
+    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Type | TypeString | undefined;
+    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Sign | undefined;
+    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
+    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression | null;
+    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => BoxedExpression | undefined;
+    evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression;
+    compile?: (expr: BoxedExpression) => CompiledExpression;
 };
 /**
  * @category Definitions
@@ -1143,7 +1441,7 @@ export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHa
  */
 export type SymbolAttributes = {
     /**
-     * If `true` the value of the symbol is constant. The value or domain of
+     * If `true` the value of the symbol is constant. The value or type of
      * symbols with this attribute set to `true` cannot be changed.
      *
      * If `false`, the symbol is a variable.
@@ -1157,61 +1455,36 @@ export type SymbolAttributes = {
   
   <div className="symbols-table">
   
-  | Operation | `"never"` | `"simplify"` | `"evaluate"` | `"N"` |
-  | :--- | :----- |
-  | `canonical()`|  (X) | | | |
-  | `simplify()` |   (X) | (X) | | |
-  | `evaluate()` |   (X) | (X) | (X) | |
-  | `"N()"` |  (X) | (X)  |  (X) | (X)  |
+  | Operation     | `"never"` | `"evaluate"` | `"N"` |
+  | :---          | :-----:   | :----:      | :---:  |
+  | `canonical()` |    (X)    |              |       |
+  | `evaluate()`  |    (X)    |     (X)      |       |
+  | `"N()"`       |    (X)    |     (X)      |  (X)  |
   
   </div>
   
     * Some examples:
-    * - `i` has `holdUntil: 'never'`
-    * - `GoldenRatio` has `holdUntil: 'simplify'` (symbolic constant)
+    * - `ImaginaryUnit` has `holdUntil: 'never'`: it is substituted during canonicalization
     * - `x` has `holdUntil: 'evaluate'` (variables)
     * - `Pi` has `holdUntil: 'N'` (special numeric constant)
     *
     * **Default:** `evaluate`
     */
-    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
+    holdUntil: 'never' | 'evaluate' | 'N';
 };
 /**
- * When used in a `SymbolDefinition`, these flags are optional.
+ * When used in a `SymbolDefinition` or `Functiondefinition` these flags
+ * provide additional information about the value of the symbol or function.
  *
  * 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;
+    sgn: Sign | undefined;
     even: boolean | undefined;
     odd: boolean | undefined;
-    prime: boolean | undefined;
-    composite: boolean | undefined;
 };
 /**
  * @noInheritDoc
@@ -1219,14 +1492,34 @@ export type NumericFlags = {
  */
 export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<NumericFlags> {
     get value(): BoxedExpression | undefined;
-    set value(val: SemiBoxedExpression | number | undefined);
-    domain: BoxedDomain | undefined;
-    inferredDomain: boolean;
+    set value(val: BoxedExpression | number | undefined);
+    readonly isFunction: boolean;
+    readonly isConstant: boolean;
+    eq?: (a: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression) => boolean | undefined;
+    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    inferredType: boolean;
+    type: Type;
 }
+/**
+ * Given an expression and set of wildcards, return a new expression.
+ *
+ * For example:
+ *
+ * ```ts
+ * {
+ *    match: '_x',
+ *    replace: (expr, {_x}) => { return ['Add', 1, _x] }
+ * }
+ * ```
+ *
+ * @category Rules */
+export type RuleReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression | undefined;
 /** @category Rules */
-export type PatternReplaceFunction = (expr: BoxedExpression, wildcards: BoxedSubstitution) => BoxedExpression;
+export type RuleConditionFunction = (wildcards: BoxedSubstitution, ce: IComputeEngine) => boolean;
 /** @category Rules */
-export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: IComputeEngine) => boolean;
+export type RuleFunction = (expr: BoxedExpression) => undefined | BoxedExpression | RuleStep;
+export declare function isRuleStep(x: any): x is RuleStep;
 /**
  * A rule describes how to modify an expressions that matches a pattern `match`
  * into a new expression `replace`.
@@ -1249,8 +1542,15 @@ export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: ICompu
  * a sequence of one or more expressions, and bind the sequence to the
  * wildcard name.
  *
- * If `exact` is false, the rule will match variants. For example
- * 'x' will match 'a + x', 'x' will match 'ax', etc...
+ * Sequence wildcards are useful when the number of elements in the sequence
+ * is not known in advance. For example, in a sum, the number of terms is
+ * not known in advance. ["Add", 0, `__a`] will match two or more terms and
+ * the `__a` wildcard will be a sequence of the matchign terms.
+ *
+ * If `exact` is false, the rule will match variants.
+ *
+ * For example 'x' will match 'a + x', 'x' will match 'ax', etc...
+ *
  * For simplification rules, you generally want `exact` to be true, but
  * to solve equations, you want it to be false. Default to true.
  *
@@ -1258,25 +1558,45 @@ export type PatternConditionFunction = (wildcards: BoxedSubstitution, ce: ICompu
  *
  * @category Rules
  */
-export type Rule = string | {
-    match: LatexString | SemiBoxedExpression | Pattern;
-    replace: LatexString | SemiBoxedExpression | PatternReplaceFunction;
-    condition?: LatexString | PatternConditionFunction;
-    exact?: boolean;
-    priority?: number;
+export type Rule = string | RuleFunction | {
+    match?: LatexString | SemiBoxedExpression | Pattern;
+    replace: LatexString | SemiBoxedExpression | RuleReplaceFunction | RuleFunction;
+    condition?: LatexString | RuleConditionFunction;
+    useVariations?: boolean;
     id?: string;
 };
-/** @category Rules */
+/**
+ *
+ * If the `match` property is `undefined`, all expressions match this rule
+ * and `condition` should also be `undefined`. The `replace` property should
+ * be a `BoxedExpression` or a `RuleFunction`, and further filtering can be
+ * done in the `replace` function.
+ *
+ * @category Rules */
 export type BoxedRule = {
-    match: Pattern;
-    replace: BoxedExpression | PatternReplaceFunction;
-    condition: undefined | PatternConditionFunction;
-    priority: number;
-    exact?: boolean;
+    /** @internal */
+    readonly _tag: 'boxed-rule';
+    match: undefined | Pattern;
+    replace: BoxedExpression | RuleReplaceFunction | RuleFunction;
+    condition: undefined | RuleConditionFunction;
+    useVariations?: boolean;
     id?: string;
 };
-/** @category Rules */
-export type BoxedRuleSet = Iterable<BoxedRule>;
+export declare function isBoxedRule(x: any): x is BoxedRule;
+export type RuleStep = {
+    value: BoxedExpression;
+    because: string;
+};
+export type RuleSteps = RuleStep[];
+/**
+ * To create a BoxedRuleSet use the `ce.rules()` method.
+ *
+ * Do not create a `BoxedRuleSet` directly.
+ *
+ * @category Rules */
+export type BoxedRuleSet = {
+    rules: ReadonlyArray<BoxedRule>;
+};
 /**
  * @noInheritDoc
  *
@@ -1315,47 +1635,31 @@ export type BoxedSubstitution = Substitution<BoxedExpression>;
  */
 export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
 export type CanonicalOptions = boolean | CanonicalForm | CanonicalForm[];
-/** @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>[]];
 /** Options for `BoxedExpression.simplify()`
  *
  * @category Compute Engine
  */
 export type SimplifyOptions = {
-    recursive?: boolean;
-    rules?: null | BoxedRuleSet;
+    /**
+     * The set of rules to apply. If `null`, use no rules. If not provided,
+     * use the default simplification rules.
+     */
+    rules?: null | Rule | ReadonlyArray<BoxedRule | Rule> | BoxedRuleSet;
+    /**
+     * Use this cost function to determine if a simplification is worth it.
+     *
+     * If not provided, `ce.costFunction`, the cost function of the engine is
+     * used.
+     */
+    costFunction?: (expr: BoxedExpression) => number;
 };
 /** Options for `BoxedExpression.evaluate()`
  *
  * @category Boxed Expression
  */
 export type EvaluateOptions = {
-    numericMode?: boolean;
+    numericApproximation?: boolean;
 };
-/** Options for `BoxedExpression.N()`
- *
- * @category Boxed Expression
- */
-export type NOptions = {};
-/**
- * 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';
 /**
  * Metadata that can be associated with a `BoxedExpression`
  *
@@ -1378,22 +1682,19 @@ export type Metadata = {
  */
 export type AngularUnit = 'rad' | 'deg' | 'grad' | 'turn';
 /** @category Compute Engine */
-export type ArrayValue = boolean | number | string | Decimal | Complex | BoxedExpression | undefined;
+export type ArrayValue = boolean | number | string | BigNum | BoxedExpression | undefined;
 /** @category Assumptions */
 export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
 /** @category Compute Engine */
-export type AssignValue = boolean | number | string | Decimal | Complex | LatexString | SemiBoxedExpression | ((ce: IComputeEngine, args: any) => BoxedExpression) | undefined;
+export type AssignValue = boolean | number | string | LatexString | SemiBoxedExpression | ((args: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+    engine: IComputeEngine;
+}) => BoxedExpression) | undefined;
 /** @internal */
-export interface IComputeEngine {
+export interface IComputeEngine extends IBigNum {
     latexDictionary: readonly LatexDictionaryEntry[];
     /** @private */
     indexedLatexDictionary: IndexedLatexDictionary;
     decimalSeparator: LatexString;
-    readonly Anything: BoxedDomain;
-    readonly Void: BoxedDomain;
-    readonly Strings: BoxedDomain;
-    readonly Booleans: BoxedDomain;
-    readonly Numbers: BoxedDomain;
     readonly True: BoxedExpression;
     readonly False: BoxedExpression;
     readonly Pi: BoxedExpression;
@@ -1409,54 +1710,63 @@ export interface IComputeEngine {
     readonly NegativeInfinity: BoxedExpression;
     readonly ComplexInfinity: BoxedExpression;
     /** @internal */
-    readonly _BIGNUM_NAN: Decimal;
+    readonly _BIGNUM_NAN: BigNum;
     /** @internal */
-    readonly _BIGNUM_ZERO: Decimal;
+    readonly _BIGNUM_ZERO: BigNum;
     /** @internal */
-    readonly _BIGNUM_ONE: Decimal;
+    readonly _BIGNUM_ONE: BigNum;
     /** @internal */
-    readonly _BIGNUM_TWO: Decimal;
+    readonly _BIGNUM_TWO: BigNum;
     /** @internal */
-    readonly _BIGNUM_HALF: Decimal;
+    readonly _BIGNUM_HALF: BigNum;
     /** @internal */
-    readonly _BIGNUM_PI: Decimal;
+    readonly _BIGNUM_PI: BigNum;
     /** @internal */
-    readonly _BIGNUM_NEGATIVE_ONE: Decimal;
+    readonly _BIGNUM_NEGATIVE_ONE: BigNum;
     /** The current scope */
     context: RuntimeScope | null;
     /** Absolute time beyond which evaluation should not proceed
      * @internal
      */
     deadline?: number;
+    generation: number;
     /** @hidden */
     readonly timeLimit: number;
     /** @hidden */
     readonly iterationLimit: number;
     /** @hidden */
     readonly recursionLimit: number;
-    numericMode: NumericMode;
-    tolerance: number;
-    angularUnit: AngularUnit;
     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;
+    chop(n: BigNum): BigNum | 0;
+    chop(n: number | BigNum): number | BigNum;
+    bignum: (a: string | number | bigint | BigNum) => BigNum;
     complex: (a: number | Complex, b?: number) => Complex;
-    isComplex(a: unknown): a is Complex;
-    set precision(p: number | 'machine');
+    /** @internal */
+    _numericValue(value: number | bigint | OneOf<[BigNum | NumericValueData | ExactNumericValueData]>): NumericValue;
+    /** If the precision is set to `machine`, floating point numbers
+     * are represented internally as a 64-bit floating point number (as
+     * per IEEE 754-2008), with a 52-bit mantissa, which gives about 15
+     * digits of precision.
+     *
+     * If the precision is set to `auto`, the precision is set to 300 digits.
+     *
+     */
+    set precision(p: number | 'machine' | 'auto');
     get precision(): number;
+    tolerance: number;
+    angularUnit: AngularUnit;
     costFunction: (expr: BoxedExpression) => number;
     strict: boolean;
-    box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
+    box(expr: NumericValue | SemiBoxedExpression, options?: {
         canonical?: CanonicalOptions;
+        structural?: boolean;
     }): BoxedExpression;
-    function(head: string | BoxedExpression, ops: ReadonlyArray<SemiBoxedExpression>, options?: {
+    function(name: string, ops: ReadonlyArray<SemiBoxedExpression>, options?: {
         metadata?: Metadata;
         canonical?: CanonicalOptions;
+        structural?: boolean;
     }): BoxedExpression;
-    number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
+    number(value: number | bigint | string | NumericValue | MathJsonNumber | BigNum | Complex | Rational, options?: {
         metadata?: Metadata;
         canonical?: CanonicalOptions;
     }): BoxedExpression;
@@ -1465,22 +1775,14 @@ export interface IComputeEngine {
         canonical?: CanonicalOptions;
     }): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
-    domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
-    error(message: MathJsonIdentifier | [MathJsonIdentifier, ...ReadonlyArray<SemiBoxedExpression>], where?: SemiBoxedExpression): BoxedExpression;
-    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
+    error(message: string | string[], where?: string): BoxedExpression;
+    typeError(expectedType: Type, actualType: undefined | Type, where?: SemiBoxedExpression): BoxedExpression;
     hold(expr: SemiBoxedExpression): BoxedExpression;
-    add(...ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-    mul(...ops: ReadonlyArray<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: ReadonlyArray<number>, metadata?: Metadata): BoxedExpression;
-    tuple(elements: ReadonlyArray<BoxedExpression>, metadata?: Metadata): BoxedExpression;
-    array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
-    rules(rules: Rule[]): BoxedRuleSet;
+    tuple(...elements: ReadonlyArray<number>): BoxedExpression;
+    tuple(...elements: ReadonlyArray<BoxedExpression>): BoxedExpression;
+    rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
+        canonical?: boolean;
+    }): BoxedRuleSet;
     /**
      * Return a set of built-in rules.
      */
@@ -1488,7 +1790,8 @@ export interface IComputeEngine {
     /**
      * This is a primitive to create a boxed function.
      *
-     * In general, consider using `ce.box()` or `canonicalXXX()` instead.
+     * In general, consider using `ce.box()` or `ce.function()` or
+     * `canonicalXXX()` instead.
      *
      * The caller must ensure that the arguments are in canonical form:
      * - arguments are `canonical()`
@@ -1497,7 +1800,7 @@ export interface IComputeEngine {
      *
      * @internal
      */
-    _fn(head: string | BoxedExpression, ops: ReadonlyArray<BoxedExpression>, options?: Metadata & {
+    _fn(name: string, ops: ReadonlyArray<BoxedExpression>, options?: Metadata & {
         canonical?: boolean;
     }): BoxedExpression;
     parse(latex: null, options?: Partial<ParseLatexOptions> & {
@@ -1516,7 +1819,7 @@ export interface IComputeEngine {
     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;
+    lookupFunction(name: string, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     assign(ids: {
         [id: string]: AssignValue;
     }): IComputeEngine;
@@ -1525,23 +1828,23 @@ export interface IComputeEngine {
         [id: string]: AssignValue;
     }, arg2?: AssignValue): IComputeEngine;
     declare(identifiers: {
-        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
+        [id: string]: Type | TypeString | OneOf<[SymbolDefinition | FunctionDefinition]>;
     }): IComputeEngine;
-    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+    declare(id: string, def: Type | TypeString | SymbolDefinition | FunctionDefinition): IComputeEngine;
     declare(arg1: string | {
-        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
-    }, arg2?: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
-    assume(predicate: SemiBoxedExpression): AssumeResult;
+        [id: string]: Type | TypeString | OneOf<[SymbolDefinition | FunctionDefinition]>;
+    }, arg2?: Type | OneOf<[SymbolDefinition | FunctionDefinition]>): IComputeEngine;
+    assume(predicate: BoxedExpression): AssumeResult;
     forget(symbol?: string | string[]): void;
     get assumptions(): ExpressionMapInterface<boolean>;
-    ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
-    verify(query: SemiBoxedExpression): boolean;
+    ask(pattern: BoxedExpression): BoxedSubstitution[];
+    verify(query: BoxedExpression): boolean;
     /** @internal */
     shouldContinueExecution(): boolean;
     /** @internal */
     checkContinueExecution(): void;
     /** @internal */
-    cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
+    cache<T>(name: string, build: () => T, purge?: (t: T) => T | undefined): T;
     /** @internal */
     readonly stats: ComputeEngineStats;
     /** @internal */
@@ -1585,7 +1888,7 @@ export type JsonSerializationOptions = {
      *
      * **Default**: `["all"]`
      */
-    shorthands: ('all' | 'number' | 'symbol' | 'function' | 'dictionary' | 'string')[];
+    shorthands: ('all' | 'number' | 'symbol' | 'function' | '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.
@@ -1619,10 +1922,16 @@ export type LatexString = string;
 /**
  * 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.
+ * - `substitution`: if present, assumes these values for the named wildcards,
+ *    and ensure that subsequent occurrence of the same wildcard have the same
+ *    value.
+ * - `recursive`: if true, match recursively, otherwise match only the top
+ *    level.
+ * - `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. **Default**: `true`
  *
  * @category Pattern Matching
  *
@@ -1630,20 +1939,21 @@ export type LatexString = string;
 export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
     recursive?: boolean;
-    numericTolerance?: number;
-    exact?: boolean;
+    useVariations?: boolean;
 };
 /**
  * @category Boxed Expression
  *
  */
 export type ReplaceOptions = {
-    /** If `true`, apply replacement rules to all sub-expressions.
+    /**
+     * If `true`, apply replacement rules to all sub-expressions.
+     *
      * If `false`, only consider the top-level expression.
      *
      * **Default**: `false`
      */
-    recursive?: boolean;
+    recursive: boolean;
     /**
      * If `true`, stop after the first rule that matches.
      *
@@ -1651,23 +1961,44 @@ export type ReplaceOptions = {
      *
      * **Default**: `false`
      */
-    once?: boolean;
+    once: boolean;
+    /**
+     * If `true` the rule will use some equivalent variations to match.
+     *
+     * For example when `useVariations` is true:
+     * - `x` matches `a + x` with a = 0
+     * - `x` matches `ax` with a = 1
+     * - etc...
+     *
+     * Setting this to `true` can save time by condensing multiple rules
+     * into one. This can be particularly useful when describing equations
+     * solutions. However, it can lead to infinite recursion and should be
+     * used with caution.
+     *
+     */
+    useVariations: 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.
+     * Note that if `once` is true, `iterationLimit` has no effect.
      *
      * **Default**: `1`
      */
-    iterationLimit?: number;
+    iterationLimit: number;
+    /**
+     * Indicate if the expression should be canonicalized after the replacement.
+     * If not provided, the expression is canonicalized if the expression
+     * that matched the pattern is canonical.
+     */
+    canonical: CanonicalOptions;
 };
 /**
  * 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.
+ * rule whose `match` is always a symbol.
 
 * @category Boxed Expression
  */
@@ -1692,7 +2023,7 @@ export interface ExpressionMapInterface<U> {
  *
  * @category Definitions
  */
-export type RuntimeIdentifierDefinitions = Map<string, BoxedSymbolDefinition | BoxedFunctionDefinition>;
+export type RuntimeIdentifierDefinitions = Map<string, OneOf<[BoxedSymbolDefinition, BoxedFunctionDefinition]>>;
 /**
  * A scope is a set of names in a dictionary that are bound (defined) in
  * a MathJSON expression.
@@ -1744,13 +2075,13 @@ export type RuntimeScope = Scope & {
     assumptions: undefined | ExpressionMapInterface<boolean>;
 };
 /**
- * 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)
+ * A bound symbol (i.e. one with an associated definition) has either a type
+ * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... type = 'real')
  * @category Definitions
  */
 export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
-    domain?: DomainLiteral | BoxedDomain;
-    /** If true, the domain is inferred, and could be adjusted later
+    type?: Type | TypeString;
+    /** If true, the type is inferred, and could be adjusted later
      * as more information becomes available or if the symbol is explicitly
      * declared.
      */
@@ -1758,20 +2089,67 @@ export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
     /** `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);
+    value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => BoxedExpression | null);
     flags?: Partial<NumericFlags>;
+    eq?: (a: BoxedExpression) => boolean | undefined;
+    neq?: (a: BoxedExpression) => boolean | undefined;
+    cmp?: (a: BoxedExpression) => '=' | '>' | '<' | undefined;
+    collection?: Partial<CollectionHandlers>;
 };
 /**
  * Definition record for a function.
  * @category Definitions
  *
  */
-export type FunctionDefinition = BaseDefinition & Partial<CollectionHandlers> & Partial<FunctionDefinitionFlags> & {
+export type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
+    /**
+     * The function signature.
+     *
+     * If a `type` handler is provided, the return type of the function should
+     * be a subtype of the return type in the signature.
+     *
+     */
+    signature?: Type | TypeString;
+    /**
+     * The actual type of the result based on the arguments.
+     *
+     * Should be a subtype of the type indicated in the signature.
+     *
+     * Do not evaluate the arguments.
+     *
+     * The type of the arguments can be used to determine the type of the
+     * result.
+     *
+     */
+    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Type;
+    /** Return the sign of the function expression.
+     *
+     * If the sign cannot be determined, return `undefined`.
+     *
+     * When determining the sign, only literal values and the values of
+     * symbols, if they are literals, should be considered.
+     *
+     * Do not evaluate the arguments.
+     *
+     * The type and sign of the arguments can be used to determine the sign.
+     *
+     */
+    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => Sign | undefined;
+    /** Return true of the function expression is even, false if it is odd and
+     * undefined if it is neither.
+     */
+    even?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => boolean | undefined;
     /**
      * A number used to order arguments.
      *
-     * Argument with higher complexity are placed after arguments with lower
-     * complexity when ordered canonically in commutative functions.
+     * 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
@@ -1788,69 +2166,21 @@ export type FunctionDefinition = BaseDefinition & Partial<CollectionHandlers> &
      * **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 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 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.
+     * This handler should validate the type 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.
+     * If the type of an argument is not compatible, it should be indicated
+     * with an `incompatible-type` error.
      *
      * `["Sequence"]` expressions are not folded and need to be handled
      *  explicitly.
@@ -1859,9 +2189,6 @@ export type FunctionSignature = {
      * 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"`.
@@ -1877,35 +2204,9 @@ export type FunctionSignature = {
      * the handler should return `null`.
      *
      */
-    canonical?: (ce: IComputeEngine, args: ReadonlyArray<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: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
+    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+        engine: IComputeEngine;
+    }) => BoxedExpression | null;
     /**
      * Evaluate a function expression.
      *
@@ -1914,70 +2215,46 @@ export type FunctionSignature = {
      *
      * 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()`.
+     * If performing numerical calculations and `options.numericalApproximation`
+     * is `false` return an exact numeric value, for example return a rational
+     * number or a square root, rather than a floating point approximation.
+     * Use `ce.number()` to create the numeric value.
      *
-     * When doing an exact calculation:
+     * When `numericalApproximation` is `false`, return a floating point number:
      * - 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
+     * If the expression cannot be evaluated, due to the values, types, or
      * assumptions about its arguments, for example, return `undefined` or
      * an `["Error"]` expression.
      */
-    evaluate?: SemiBoxedExpression | ((ce: IComputeEngine, args: ReadonlyArray<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: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
+    evaluate?: ((ops: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => BoxedExpression | undefined) | BoxedExpression;
     /** Dimensional analysis
      * @experimental
      */
-    evalDimension?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => BoxedExpression;
-    /** Return the sign of the function expression. */
-    sgn?: (ce: IComputeEngine, args: ReadonlyArray<BoxedExpression>) => -1 | 0 | 1 | undefined;
+    evalDimension?: (args: ReadonlyArray<BoxedExpression>, options: EvaluateOptions & {
+        engine: IComputeEngine;
+    }) => BoxedExpression;
     /** Return a compiled (optimized) expression. */
     compile?: (expr: BoxedExpression) => CompiledExpression;
+    collection?: Partial<CollectionHandlers>;
+};
+/**
+ * @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 operator. */
+    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;
 };