@cortex-js/compute-engine 0.7.0 → 0.8.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.7.0 */
+/** CortexJS Compute Engine 0.8.0 */
 /** @internal */
 function isSymbolEntry(entry) {
     return !('kind' in entry) || entry.kind === 'symbol';
@@ -29,7 +29,7 @@ function isEnvironmentEntry(entry) {
 }
 
 /*!
- *  decimal.js v10.4.0
+ *  decimal.js v10.4.1
  *  An arbitrary-precision Decimal type for JavaScript.
  *  https://github.com/MikeMcl/decimal.js
  *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
@@ -7287,8 +7287,23 @@ function numeratorDenominator(expr) {
                 }
             }
         }
+        else if (head(arg) === 'Rational' && nops(arg) === 2) {
+            const op1 = op(arg, 1);
+            const op2 = op(arg, 2);
+            if (machineValue(op1) !== 1)
+                numerator.push(op1);
+            if (machineValue(op2) !== 1)
+                denominator.push(op2);
+        }
         else {
-            numerator.push(arg);
+            const [n, d] = rationalValue(arg);
+            if (n !== null) {
+                if (n !== 1)
+                    numerator.push(n);
+                denominator.push(d);
+            }
+            else
+                numerator.push(arg);
         }
     }
     return [numerator, denominator];
@@ -7422,15 +7437,12 @@ function serializeMultiply(serializer, expr) {
     const [numer, denom] = numeratorDenominator(expr);
     if (denom.length > 0) {
         if (denom.length === 1 && denom[0] === 1) {
-            if (numer.length === 0) {
+            if (numer.length === 0)
                 result = '1';
-            }
-            else if (numer.length === 1) {
+            else if (numer.length === 1)
                 result = serializer.serialize(numer[0]);
-            }
-            else {
+            else
                 result = serializeMultiply(serializer, [MULTIPLY, ...numer]);
-            }
         }
         else {
             result = serializer.serialize([
@@ -7986,7 +7998,11 @@ const DEFINITIONS_ARITHMETIC = [
     {
         name: 'Rational',
         precedence: 660,
-        serialize: serializeFraction,
+        serialize: (serializer, expr) => {
+            if (expr && nops(expr) === 1)
+                return '\\mathrm{Rational}' + serializer.wrapArguments(expr);
+            return serializeFraction(serializer, expr);
+        },
     },
     {
         name: ROOT,
@@ -14914,8 +14930,8 @@ function preferDecimal(ce) {
     return (ce.numericMode === 'decimal' ||
         (ce.numericMode === 'auto' && ce.precision > Math.floor(MACHINE_PRECISION)));
 }
-/** If result of a numeric evaluation is a complex number,
- * return `NaN` if `ce.useComplex` is false
+/** When result of a numeric evaluation is a complex number,
+ * return `NaN` if not `complexallowed()`
  */
 function complexAllowed(ce) {
     return ce.numericMode === 'auto' || ce.numericMode === 'complex';
@@ -14968,20 +14984,32 @@ class AbstractBoxedExpression {
         if (metadata?.wikidata !== undefined)
             this._wikidata = metadata.wikidata;
     }
-    /** Object.toJSON(), called by JSON.Stringify */
-    toJSON() {
-        return JSON.stringify(this.json);
+    /** `Object.valueOf()`: return a primitive value for the object
+     *
+     */
+    valueOf() {
+        if (this.symbol === 'True')
+            return true;
+        if (this.symbol === 'False')
+            return false;
+        return (this.asFloat ?? this.string ?? this.symbol ?? JSON.stringify(this.json));
     }
     /** Object.toString() */
     toString() {
-        return this.latex;
+        return String(this.valueOf());
     }
-    /** Object.valueOf(): return a primitive value for the object */
-    valueOf() {
-        const [n, d] = this.rationalValue;
-        if (n !== null && d !== null)
-            return [n, d];
-        return this.asFloat ?? this.string ?? this.symbol ?? this.toString();
+    [Symbol.toPrimitive](hint) {
+        if (hint === 'string')
+            return this.toString();
+        if (hint === 'number') {
+            const v = this.valueOf();
+            return typeof v === 'number' ? v : null;
+        }
+        return this.toString();
+    }
+    /** Called by `JSON.stringify()` when serializing to json */
+    toJSON() {
+        return this.json;
     }
     /** Object.is() */
     is(rhs) {
@@ -14989,49 +15017,20 @@ class AbstractBoxedExpression {
             return false;
         return this.isSame(this.engine.box(rhs));
     }
-    isCompatible(_dom, _kind) {
-        return false;
-    }
-    has(_v) {
-        return false;
-    }
-    get description() {
-        return [];
-    }
-    get url() {
-        return '';
-    }
-    get isPure() {
-        return false;
-    }
-    /** For a symbol, true if the symbol is a free variable (no value) */
-    get isFree() {
-        return false;
-    }
-    /** For a symbol, true if the symbol is a constant (unchangeable value) */
-    get isConstant() {
-        return false;
-    }
-    get isLiteral() {
-        return false;
-    }
     get latex() {
         return this._latex ?? this.engine.serialize(this);
     }
     set latex(val) {
         this._latex = val;
     }
-    get wikidata() {
-        return this._wikidata ?? '';
-    }
-    set wikidata(val) {
-        this._wikidata = val;
+    get symbol() {
+        return null;
     }
-    get complexity() {
-        return 1;
+    get isNothing() {
+        return false;
     }
-    get symbols() {
-        return [...getSymbols(this, new Set())].map((x) => this.engine.symbol(x));
+    get string() {
+        return null;
     }
     getSubexpressions(head) {
         return getSubexpressions(this, head);
@@ -15039,6 +15038,9 @@ class AbstractBoxedExpression {
     get subexpressions() {
         return this.getSubexpressions('');
     }
+    get symbols() {
+        return [...getSymbols(this, new Set())].map((x) => this.engine.symbol(x));
+    }
     get errors() {
         return this.getSubexpressions('Error');
     }
@@ -15058,88 +15060,94 @@ class AbstractBoxedExpression {
     get op3() {
         return this.engine.symbol('Nothing');
     }
-    get basedDefinition() {
-        return undefined;
+    get isValid() {
+        return true;
     }
-    get symbolDefinition() {
-        return undefined;
+    get isPure() {
+        return false;
     }
-    get functionDefinition() {
-        return undefined;
+    /** For a symbol, true if the symbol is a free variable (no value) */
+    get isFree() {
+        return false;
     }
-    bind(_scope) {
-        return;
+    /** For a symbol, true if the symbol is a constant (unchangeable value) */
+    get isConstant() {
+        return false;
     }
-    unbind() {
-        return;
+    get canonical() {
+        return this;
     }
-    get keys() {
-        return null;
+    apply(_fn, _head) {
+        return this;
     }
-    get keysCount() {
-        return 0;
+    subs(_sub) {
+        return this;
     }
-    getKey(_key) {
-        return undefined;
+    solve(_vars) {
+        return null;
     }
-    hasKey(_key) {
+    replace(_rules) {
+        return null;
+    }
+    has(_v) {
         return false;
     }
-    get machineValue() {
-        return this.numericValue?.machineValue ?? null;
+    get isNaN() {
+        return undefined;
     }
-    get rationalValue() {
-        return this.numericValue?.rationalValue ?? [null, null];
+    get isZero() {
+        return undefined;
     }
-    get decimalValue() {
-        return this.numericValue?.decimalValue ?? null;
+    get isNotZero() {
+        return undefined;
     }
-    get complexValue() {
-        return this.numericValue?.complexValue ?? null;
+    get isOne() {
+        return undefined;
     }
-    get asFloat() {
-        return this.numericValue?.asFloat ?? null;
+    get isNegativeOne() {
+        return undefined;
     }
-    get asSmallInteger() {
-        return this.numericValue?.asSmallInteger ?? null;
+    get isInfinity() {
+        return undefined;
     }
-    get asRational() {
-        return this.numericValue?.asRational ?? [null, null];
+    // Not +- Infinity, not NaN
+    get isFinite() {
+        return undefined;
     }
-    get sgn() {
-        return this.numericValue?.sgn ?? null;
+    get isEven() {
+        return undefined;
     }
-    get symbol() {
-        return null;
+    get isOdd() {
+        return undefined;
     }
-    get isNothing() {
-        return false;
+    get isPrime() {
+        return undefined;
     }
-    get isValid() {
-        return true;
+    get isComposite() {
+        return undefined;
     }
-    get value() {
-        return this;
+    get machineValue() {
+        return null;
     }
-    set value(_value) {
-        throw new Error(`Can't change the value of \\(${this.latex}\\)`);
+    get rationalValue() {
+        return [null, null];
     }
-    get numericValue() {
-        return undefined;
+    get decimalValue() {
+        return null;
     }
-    isSubdomainOf(_d) {
-        return undefined;
+    get complexValue() {
+        return null;
     }
-    get domain() {
-        return this.engine.domain('Void');
+    get asFloat() {
+        return null;
     }
-    set domain(_domain) {
-        throw new Error(`Can't change the domain of \\(${this.latex}\\)`);
+    get asSmallInteger() {
+        return null;
     }
-    get explicitDomain() {
-        return this.domain;
+    get asRational() {
+        return [null, null];
     }
-    get string() {
+    get sgn() {
         return null;
     }
     isLess(_rhs) {
@@ -15154,12 +15162,6 @@ class AbstractBoxedExpression {
     isGreaterEqual(_rhs) {
         return undefined;
     }
-    get isZero() {
-        return undefined;
-    }
-    get isNotZero() {
-        return undefined;
-    }
     // x > 0
     get isPositive() {
         return undefined;
@@ -15176,16 +15178,80 @@ class AbstractBoxedExpression {
     get isNonPositive() {
         return undefined;
     }
-    get isInfinity() {
+    //
+    //
+    //
+    //
+    //
+    isCompatible(_dom, _kind) {
+        return false;
+    }
+    get description() {
         return undefined;
     }
-    get isNaN() {
+    get url() {
         return undefined;
     }
-    // Not +- Infinity, not NaN
-    get isFinite() {
+    get isLiteral() {
+        return false;
+    }
+    get wikidata() {
+        return this._wikidata;
+    }
+    set wikidata(val) {
+        this._wikidata = val;
+    }
+    get complexity() {
+        return undefined;
+    }
+    get basedDefinition() {
+        return undefined;
+    }
+    get symbolDefinition() {
+        return undefined;
+    }
+    get functionDefinition() {
+        return undefined;
+    }
+    bind(_scope) {
+        return;
+    }
+    unbind() {
+        return;
+    }
+    get keys() {
+        return null;
+    }
+    get keysCount() {
+        return 0;
+    }
+    getKey(_key) {
+        return undefined;
+    }
+    hasKey(_key) {
+        return false;
+    }
+    get value() {
+        return undefined;
+    }
+    set value(_value) {
+        throw new Error(`Can't change the value of \\(${this.latex}\\)`);
+    }
+    get numericValue() {
+        return undefined;
+    }
+    isSubdomainOf(_d) {
         return undefined;
     }
+    get domain() {
+        return this.engine.domain('Void');
+    }
+    set domain(_domain) {
+        throw new Error(`Can't change the domain of \\(${this.latex}\\)`);
+    }
+    get explicitDomain() {
+        return this.domain;
+    }
     get isNumber() {
         return undefined;
     }
@@ -15214,47 +15280,14 @@ class AbstractBoxedExpression {
     get isExtendedComplex() {
         return undefined;
     }
-    get isOne() {
-        return undefined;
-    }
-    get isNegativeOne() {
-        return undefined;
-    }
-    get isEven() {
-        return undefined;
-    }
-    get isOdd() {
-        return undefined;
-    }
-    get isPrime() {
-        return undefined;
-    }
-    get isComposite() {
-        return undefined;
-    }
-    get canonical() {
-        return this;
-    }
-    apply(_fn, _head) {
+    simplify(_options) {
         return this;
     }
     evaluate(options) {
         return this.simplify(options);
     }
-    simplify(_options) {
-        return this;
-    }
     N(_options) {
-        return this;
-    }
-    replace(_rules) {
-        return null;
-    }
-    subs(_sub) {
-        return this;
-    }
-    solve(_vars) {
-        return null;
+        return this.evaluate();
     }
 }
 
@@ -15642,12 +15675,12 @@ function order(a, b) {
         let bComplexity = 0;
         let aComplexity = 0;
         for (const key of b.keys)
-            bComplexity += b.getKey(key).complexity;
+            bComplexity += b.getKey(key).complexity ?? DEFAULT_COMPLEXITY;
         for (const key of a.keys)
-            aComplexity += a.getKey(key).complexity;
+            aComplexity += a.getKey(key).complexity ?? DEFAULT_COMPLEXITY;
         return aComplexity - bComplexity;
     }
-    return a.complexity - b.complexity;
+    return ((a.complexity ?? DEFAULT_COMPLEXITY) - (b.complexity ?? DEFAULT_COMPLEXITY));
 }
 /** Get the number of atomic elements in the expression */
 function getLeafCount(expr) {
@@ -16304,7 +16337,7 @@ function serializeJsonNumber(ce, value, metadata) {
             num =
                 value.isInteger() && value.e < value.precision() + 4
                     ? value.toFixed(0)
-                    : repeatingDecimal(ce, value.toJSON());
+                    : repeatingDecimal(ce, value.toString());
         }
         if (ce.jsonSerializationOptions.metadata.includes('latex'))
             metadata.latex = metadata.latex ?? ce.serialize({ num });
@@ -16903,20 +16936,26 @@ function includesDomain(xs, y) {
     return false;
 }
 function serialize(ce, dom) {
+    if (dom instanceof AbstractBoxedExpression)
+        return dom.json;
     if (typeof dom === 'string')
-        return serializeJsonSymbol(ce, dom);
+        return dom;
     if (dom[0] === 'Error') {
         if (dom[2])
-            return ['Error', dom[1], dom[2]];
-        return ['Error', dom[1]];
+            return [
+                'Error',
+                serialize(ce, dom[1]),
+                serialize(ce, dom[2]),
+            ];
+        return [
+            'Error',
+            serialize(ce, dom[1]),
+        ];
     }
     const result = [serializeJsonSymbol(ce, dom[0])];
-    for (let i = 1; i <= dom.length - 1; i++) {
-        if (dom[i] instanceof AbstractBoxedExpression)
-            result.push(dom[i].json);
-        else
-            result.push(serialize(ce, dom[i]));
-    }
+    if (dom.length > 1)
+        for (let i = 1; i <= dom.length - 1; i++)
+            serialize(ce, dom[i]);
     return result;
 }
 function hash(dom) {
@@ -17739,17 +17778,40 @@ function cheapest(oldExpr, newExpr) {
  * BoxedFunction
  */
 class BoxedFunction extends AbstractBoxedExpression {
-    constructor(ce, head, ops, metadata) {
-        super(ce, metadata);
+    constructor(ce, head, ops, options) {
+        options ?? (options = {});
+        options.canonical ?? (options.canonical = false);
+        super(ce, options.metadata);
         this._scope = ce.context;
-        this._head = typeof head === 'string' ? head : head.symbol ?? head;
+        this._head = head;
         this._ops = ops;
-        this._def = null; // Mark the def as not cached
+        if (options.canonical)
+            this._canonical = this;
+        this._def = options.def ?? null; // Mark the def as not yet cached if none is provided
         this._codomain = null;
-        this._isCanonical = false;
+        if (typeof this._head !== 'string')
+            this._codomain = this._head.domain.codomain;
+        else if (this._def) {
+            const sig = this._def.signature;
+            if (typeof sig.codomain === 'function') {
+                this._codomain =
+                    sig.codomain(ce, this._ops.map((x) => x.domain)) ?? null;
+            }
+            else {
+                this._codomain = sig.codomain ?? null;
+            }
+        }
+        if (!this._codomain)
+            this._codomain = ce.defaultDomain ?? ce.domain('Void');
         // Note: _isPure is computed on demand and cached
         ce._register(this);
     }
+    //
+    // NON-CANONICAL OR CANONICAL OPERATIONS
+    //
+    // Those operations/properties can be applied to a canonical or
+    // non-canonical expression
+    //
     get hash() {
         if (this._hash !== undefined)
             return this._hash;
@@ -17763,88 +17825,41 @@ class BoxedFunction extends AbstractBoxedExpression {
         this._hash = h;
         return h;
     }
-    unbind() {
-        if (typeof this._head !== 'string')
-            this._head.unbind();
-        for (const arg of this._ops)
-            arg.unbind();
-        if (this._value)
-            this._value.unbind();
-        if (this._numericValue)
-            this._numericValue.unbind();
-    }
-    get wikidata() {
-        return this._wikidata ?? this.functionDefinition?.wikidata ?? '';
-    }
-    get description() {
-        const def = this.functionDefinition;
-        if (!def)
-            return [];
-        if (!def.description)
-            return [];
-        if (typeof def.description === 'string')
-            return [def.description];
-        return def.description;
-    }
-    get url() {
-        return this.functionDefinition?.url ?? '';
-    }
-    get complexity() {
-        return this.functionDefinition?.complexity ?? DEFAULT_COMPLEXITY;
-    }
-    get head() {
-        return this._head;
+    get isCanonical() {
+        return this._canonical === this;
     }
-    get value() {
-        if (!this.isPure)
-            return undefined;
-        // Use cached value if the function is pure
-        if (this._value)
-            return this._value;
-        this._value = this.evaluate();
-        return this._value;
+    set isCanonical(val) {
+        this._canonical = val ? this : undefined;
     }
-    get numericValue() {
-        if (!this.isPure)
-            return undefined;
-        if (this._numericValue)
-            return this._numericValue;
-        const val = this.N();
-        this._numericValue = val.isLiteral ? val : undefined;
-        return this._numericValue;
+    get isLiteral() {
+        return false;
     }
     get isPure() {
+        if (!this.isCanonical)
+            return false;
         if (this._isPure !== undefined)
             return this._isPure;
         let result = undefined;
         if (this.functionDefinition?.pure !== undefined)
             result = this.functionDefinition.pure;
-        if (result !== false) {
-            // The function might be pure. Let's check that all its arguments are pure.
+        // The function might be pure. Let's check that all its arguments are pure.
+        if (result !== false)
             result = this._ops.every((x) => x.isPure);
-        }
         this._isPure = result;
         return result;
     }
-    get isLiteral() {
-        return false;
+    get json() {
+        // If this expression is canonical, apply some transformations to the
+        // JSON serialization to "reverse" some of the effects of canonicalization.
+        if (this._canonical === this)
+            return serializeJsonCanonicalFunction(this.engine, this._head, this._ops, { latex: this._latex, wikidata: this._wikidata });
+        return serializeJsonFunction(this.engine, this._head, this._ops, {
+            latex: this._latex,
+            wikidata: this._wikidata,
+        });
     }
-    get isValid() {
-        if (typeof this._head !== 'string') {
-            if (this._head.isValid === false)
-                return false;
-        }
-        else {
-            if (this._head === 'Error')
-                return false;
-            // Need to check function definition before arguments: binding
-            // as the side effect of normalizing arguments
-            if (this.functionDefinition === undefined)
-                return false;
-            if (!this._ops.every((x) => x.isValid))
-                return false;
-        }
-        return this._ops.every((x) => x.isValid);
+    get head() {
+        return this._head;
     }
     get ops() {
         return this._ops;
@@ -17861,70 +17876,251 @@ class BoxedFunction extends AbstractBoxedExpression {
     get op3() {
         return this._ops[2] ?? this.engine.symbol('Nothing');
     }
-    get functionDefinition() {
-        if (this._def !== null)
-            return this._def;
-        this.bind(this._scope);
-        return this._def;
-    }
-    bind(scope) {
-        this._def = undefined;
-        const ce = this.engine;
-        // Flatten the sequence, canonicalize
-        this._ops = flattenSequence(this._ops.map((x) => x.canonical));
-        // Is the head an expression?
-        // For example, `['InverseFunction', 'Sin']`
+    get isValid() {
         if (typeof this._head !== 'string') {
-            const head = this._head.evaluate().symbol ?? this._head;
-            this._head = head;
-            if (typeof this._head !== 'string') {
-                this._codomain = this._head.domain.codomain ?? ce.domain('Void');
-                return;
-            }
+            if (this._head.isValid === false)
+                return false;
+            return this._ops.every((x) => x.isValid);
         }
-        scope = scope ?? this._scope;
-        if (scope === null)
-            return;
-        this._def = ce.lookupFunction(this._head, scope);
-        if (this._def) {
-            if (this._def.scoped)
-                ce.pushScope();
-            // In case the def was found by the wikidata, and the name does not
-            // match the one in our dictionary, make sure to update it.
-            this._head = this._def.name;
-            // Apply Sequence, Symbol
-            this._ops = normalizeList(this._ops, this._def.hold);
-            this._ops =
-                validateSignature(ce, this._def.signature, this._ops) ?? this._ops;
-            // Calculate the effective codomain
-            if (!this._ops.every((x) => x.isValid)) {
-                this._codomain = ce.defaultDomain ?? ce.domain('Void');
-                if (this._def.scoped)
-                    ce.popScope();
-                return;
-            }
-            const sig = this._def.signature;
-            if (typeof sig.codomain === 'function') {
-                // If the signature was a match, the `sig.domain()` function must succeed
-                const opsDomain = this._ops.map((x) => x.domain);
-                this._codomain = sig.codomain(ce, opsDomain);
+        if (this._head === 'Error')
+            return false;
+        // If this expression is not canonical, nothing else to check:
+        // non-canonical expression are never bound
+        if (this._canonical !== this)
+            return true;
+        // Need to check function definition before arguments: binding
+        // as the side effect of normalizing arguments
+        if (this.functionDefinition === undefined)
+            return false;
+        if (!this._ops.every((x) => x.isValid))
+            return false;
+        return true;
+    }
+    get canonical() {
+        if (this._canonical)
+            return this._canonical;
+        if (this.isValid)
+            this._canonical = makeCanonicalFunction(this.engine, this._head, this._ops);
+        else
+            this._canonical = this;
+        return this._canonical;
+    }
+    *map(fn) {
+        let i = 0;
+        while (i < this._ops.length)
+            yield fn(this._ops[i++]);
+    }
+    apply(fn, head) {
+        const newHead = head ?? this.head;
+        let opsChanged = false;
+        const ops = [];
+        for (const arg of this._ops) {
+            const newArg = fn(arg);
+            if (arg !== newArg)
+                opsChanged = true;
+            ops.push(this.engine.box(newArg));
+        }
+        if (!opsChanged && this.head === newHead)
+            return this;
+        return this.engine.fn(newHead, ops);
+    }
+    subs(sub) {
+        return makeCanonicalFunction(this.engine, this._head, this._ops.map((x) => x.subs(sub)));
+    }
+    replace(rules, options) {
+        return replace(this, rules, options);
+    }
+    has(x) {
+        if (typeof this._head === 'string') {
+            if (typeof x === 'string') {
+                if (this._head === x)
+                    return true;
             }
+            else if (x.includes(this._head))
+                return true;
+        }
+        for (const arg of this._ops)
+            if (arg.has(x))
+                return true;
+        return false;
+    }
+    /** `isSame` is structural/symbolic equality */
+    isSame(rhs) {
+        if (this === rhs)
+            return true;
+        if (!(rhs instanceof BoxedFunction))
+            return false;
+        // Number of arguments must match
+        if (this.nops !== rhs.nops)
+            return false;
+        // Head must match
+        if (typeof this.head === 'string') {
+            if (this.head !== rhs.head)
+                return false;
+        }
+        else {
+            if (typeof rhs.head === 'string')
+                return false;
+            else if (!rhs.head || !this.head.isSame(rhs.head))
+                return false;
+        }
+        // Each argument must match
+        const lhsTail = this._ops;
+        const rhsTail = rhs._ops;
+        for (let i = 0; i < lhsTail.length; i++)
+            if (!lhsTail[i].isSame(rhsTail[i]))
+                return false;
+        return true;
+    }
+    match(rhs, options) {
+        if (!(rhs instanceof BoxedFunction))
+            return null;
+        let result = {};
+        // Head must match
+        if (typeof this.head === 'string') {
+            if (this.head !== rhs.head)
+                return null;
+        }
+        else {
+            if (typeof rhs.head === 'string')
+                return null;
             else {
-                this._codomain = sig.codomain ?? ce.defaultDomain ?? ce.domain('Void');
+                if (!rhs.head)
+                    return null;
+                const m = this.head.match(rhs.head, options);
+                if (m === null)
+                    return null;
+                result = { ...result, ...m };
             }
-            if (this._def.scoped)
-                ce.popScope();
         }
-        else
-            this._codomain = ce.defaultDomain ?? ce.domain('Void');
+        // Each argument must match
+        const lhsTail = this._ops;
+        const rhsTail = rhs._ops;
+        for (let i = 0; i < lhsTail.length; i++) {
+            const m = lhsTail[i].match(rhsTail[i], options);
+            if (m === null)
+                return null;
+            result = { ...result, ...m };
+        }
+        return result;
+    }
+    //
+    // CANONICAL OPERATIONS
+    //
+    // These operations apply only to canonical expressions
+    //
+    unbind() {
+        // Note: a non-canonical expression is never bound
+        this._value = undefined;
+        this._numericValue = undefined;
+        // this._def = null;
+    }
+    get wikidata() {
+        // Since the canonical and non-canonical version of the expression
+        // may have different heads, not applicable to non-canonical expressions.
+        if (!this.isCanonical)
+            return undefined;
+        return this._wikidata ?? this.functionDefinition?.wikidata ?? undefined;
+    }
+    get description() {
+        // Since the canonical and non-canonical version of the expression
+        // may have different heads, not applicable to non-canonical expressions.
+        if (!this.isCanonical)
+            return undefined;
+        const def = this.functionDefinition;
+        if (!def)
+            return [];
+        if (!def.description)
+            return undefined;
+        if (typeof def.description === 'string')
+            return [def.description];
+        return def.description;
+    }
+    get url() {
+        // Since the canonical and non-canonical version of the expression
+        // may have different heads, not applicable to non-canonical expressions.
+        if (!this.isCanonical)
+            return '';
+        return this.functionDefinition?.url ?? undefined;
+    }
+    get complexity() {
+        // Since the canonical and non-canonical version of the expression
+        // may have different heads, not applicable to non-canonical expressions.
+        if (!this.isCanonical)
+            return undefined;
+        return this.functionDefinition?.complexity ?? DEFAULT_COMPLEXITY;
+    }
+    get functionDefinition() {
+        if (!this.isCanonical)
+            return undefined;
+        if (this._def !== null)
+            return this._def;
+        return undefined;
+    }
+    bind(_scope) {
+        debugger;
+    }
+    //
+    // AUTO-CANONICAL OPERATIONS
+    //
+    // The operations are automatically done on the canonical form of the
+    // expression
+    //
+    get value() {
+        if (!this.isCanonical)
+            return this.canonical.value ?? this.canonical;
+        if (!this.isPure)
+            return undefined;
+        // Use cached value if the function is pure
+        if (this._value)
+            return this._value;
+        this._value = this.evaluate();
+        return this._value;
+    }
+    get numericValue() {
+        if (this._numericValue)
+            return this._numericValue;
+        if (!this.isCanonical)
+            return this.canonical.numericValue;
+        if (!this.isPure)
+            this._numericValue = undefined;
+        else {
+            const v = this.N();
+            this._numericValue = v === this ? undefined : v;
+        }
+        return this._numericValue;
     }
     get domain() {
-        if (this._codomain === null)
-            this.bind(this._scope);
+        if (!this.isCanonical)
+            return this.canonical.domain;
         console.assert(this._codomain);
         return this._codomain;
     }
+    /** `isEqual` is mathematical equality */
+    isEqual(rhs) {
+        if (!this.isCanonical)
+            return this.canonical.isEqual(rhs);
+        rhs = rhs.canonical.numericValue ?? rhs.canonical;
+        if (rhs.isNumber && this.isNumber) {
+            const ce = this.engine;
+            // In general, it is impossible to always prove equality
+            // (Richardson's theorem) but this works often...
+            const diff = ce.add([this, ce.negate(rhs)]).N();
+            if (diff.isZero)
+                return true;
+            const v = diff.asFloat;
+            if (v !== null && ce.chop(v) === 0)
+                return true;
+            return (this.value ?? this.evaluate()).isSame(rhs);
+        }
+        if (this.domain.isRelationalOperator && rhs.domain.isRelationalOperator) {
+            return this.isSame(rhs);
+        }
+        return this.isSame(rhs);
+    }
     isLess(rhs) {
+        if (!this.isCanonical)
+            return this.canonical.isLess(rhs);
         if (rhs.isZero) {
             const s = this.sgn;
             if (s === null)
@@ -17933,9 +18129,15 @@ class BoxedFunction extends AbstractBoxedExpression {
                 return s < 0;
         }
         // @todo: use this.functionDefinition.range
-        return undefined;
+        const ce = this.engine;
+        rhs = rhs.canonical.numericValue ?? rhs.canonical;
+        const diff = ce.add([this, ce.negate(rhs)]).N();
+        const v = diff.asFloat;
+        return v === null ? undefined : v < 0;
     }
     isLessEqual(rhs) {
+        if (!this.isCanonical)
+            return this.canonical.isLess(rhs);
         if (rhs.isZero) {
             const s = this.sgn;
             if (s === null)
@@ -17943,10 +18145,16 @@ class BoxedFunction extends AbstractBoxedExpression {
             if (s !== undefined)
                 return s <= 0;
         }
-        return undefined;
         // @todo: use this.functionDefinition.range
+        const ce = this.engine;
+        rhs = rhs.canonical.numericValue ?? rhs.canonical;
+        const diff = ce.add([this, ce.negate(rhs)]).N();
+        const v = diff.asFloat;
+        return v === null ? undefined : v <= 0 || ce.chop(v) === 0;
     }
     isGreater(rhs) {
+        if (!this.isCanonical)
+            return this.canonical.isLess(rhs);
         if (rhs.isZero) {
             const s = this.sgn;
             if (s === null)
@@ -17954,10 +18162,16 @@ class BoxedFunction extends AbstractBoxedExpression {
             if (s !== undefined)
                 return s > 0;
         }
-        return undefined;
         // @todo: use this.functionDefinition.range
+        const ce = this.engine;
+        rhs = rhs.canonical.numericValue ?? rhs.canonical;
+        const diff = ce.add([this, ce.negate(rhs)]).N();
+        const v = diff.asFloat;
+        return v === null ? undefined : v > 0;
     }
     isGreaterEqual(rhs) {
+        if (!this.isCanonical)
+            return this.canonical.isLess(rhs);
         if (rhs.isZero) {
             const s = this.sgn;
             if (s === null)
@@ -17965,8 +18179,12 @@ class BoxedFunction extends AbstractBoxedExpression {
             if (s !== undefined)
                 return s >= 0;
         }
-        return undefined;
         // @todo: use this.functionDefinition.range
+        const ce = this.engine;
+        rhs = rhs.canonical.numericValue ?? rhs.canonical;
+        const diff = ce.add([this, ce.negate(rhs)]).N();
+        const v = diff.asFloat;
+        return v === null ? undefined : v >= 0 || ce.chop(v) === 0;
     }
     get isZero() {
         const s = this.sgn;
@@ -17987,12 +18205,10 @@ class BoxedFunction extends AbstractBoxedExpression {
         // @todo: use this.functionDefinition.range
     }
     get isOne() {
-        return undefined;
-        // @todo: use this.functionDefinition.range
+        return this.isEqual(this.engine.number(1));
     }
     get isNegativeOne() {
-        return undefined;
-        // @todo: use this.functionDefinition.range
+        return this.isEqual(this.engine.number(-1));
     }
     // x > 0
     get isPositive() {
@@ -18000,9 +18216,8 @@ class BoxedFunction extends AbstractBoxedExpression {
         if (s === null)
             return false;
         if (typeof s === 'number')
-            return s !== 0;
+            return s > 0;
         return undefined;
-        // @todo: use this.functionDefinition.range
     }
     // x <= 0
     get isNonPositive() {
@@ -18012,7 +18227,6 @@ class BoxedFunction extends AbstractBoxedExpression {
         if (typeof s === 'number')
             return s <= 0;
         return undefined;
-        // @todo: use this.functionDefinition.range
     }
     // x < 0
     get isNegative() {
@@ -18022,7 +18236,6 @@ class BoxedFunction extends AbstractBoxedExpression {
         if (typeof s === 'number')
             return s < 0;
         return undefined;
-        // @todo: use this.functionDefinition.range
     }
     // x >= 0
     get isNonNegative() {
@@ -18032,7 +18245,6 @@ class BoxedFunction extends AbstractBoxedExpression {
         if (typeof s === 'number')
             return s >= 0;
         return undefined;
-        // @todo: use this.functionDefinition.range
     }
     get isNumber() {
         return this.domain.isCompatible('Number');
@@ -18046,124 +18258,21 @@ class BoxedFunction extends AbstractBoxedExpression {
     get isAlgebraic() {
         return this.domain.isCompatible('AlgebraicNumber');
     }
-    get isReal() {
-        return this.domain.isCompatible('RealNumber');
-    }
-    get isExtendedReal() {
-        return this.domain.isCompatible('ExtendedRealNumber');
-    }
-    get isComplex() {
-        return this.domain.isCompatible('ComplexNumber');
-    }
-    get isImaginary() {
-        return this.domain.isCompatible('ImaginaryNumber');
-    }
-    get json() {
-        // If this expression is canonical, apply some transformations to the
-        // JSON serialization to "reverse" some of the effects of canonicalization.
-        if (this._isCanonical)
-            return serializeJsonCanonicalFunction(this.engine, this._head, this._ops, { latex: this._latex, wikidata: this._wikidata });
-        return serializeJsonFunction(this.engine, this._head, this._ops, {
-            latex: this._latex,
-            wikidata: this._wikidata,
-        });
-    }
-    has(x) {
-        if (typeof this._head === 'string') {
-            if (typeof x === 'string') {
-                if (this._head === x)
-                    return true;
-            }
-            else if (x.includes(this._head))
-                return true;
-        }
-        for (const arg of this._ops)
-            if (arg.has(x))
-                return true;
-        return false;
-    }
-    /** `isSame` is structural/symbolic equality */
-    isSame(rhs) {
-        if (this === rhs)
-            return true;
-        if (!(rhs instanceof BoxedFunction))
-            return false;
-        // Number of arguments must match
-        if (this.nops !== rhs.nops)
-            return false;
-        // Head must match
-        if (typeof this.head === 'string') {
-            if (this.head !== rhs.head)
-                return false;
-        }
-        else {
-            if (typeof rhs.head === 'string')
-                return false;
-            else if (!rhs.head || !this.head.isSame(rhs.head))
-                return false;
-        }
-        // Each argument must match
-        const lhsTail = this._ops;
-        const rhsTail = rhs._ops;
-        for (let i = 0; i < lhsTail.length; i++)
-            if (!lhsTail[i].isSame(rhsTail[i]))
-                return false;
-        return true;
+    get isReal() {
+        return this.domain.isCompatible('RealNumber');
     }
-    match(rhs, options) {
-        if (!(rhs instanceof BoxedFunction))
-            return null;
-        let result = {};
-        // Head must match
-        if (typeof this.head === 'string') {
-            if (this.head !== rhs.head)
-                return null;
-        }
-        else {
-            if (typeof rhs.head === 'string')
-                return null;
-            else {
-                if (!rhs.head)
-                    return null;
-                const m = this.head.match(rhs.head, options);
-                if (m === null)
-                    return null;
-                result = { ...result, ...m };
-            }
-        }
-        // Each argument must match
-        const lhsTail = this._ops;
-        const rhsTail = rhs._ops;
-        for (let i = 0; i < lhsTail.length; i++) {
-            const m = lhsTail[i].match(rhsTail[i], options);
-            if (m === null)
-                return null;
-            result = { ...result, ...m };
-        }
-        return result;
+    get isExtendedReal() {
+        return this.domain.isCompatible('ExtendedRealNumber');
     }
-    /** `isEqual` is mathematical equality */
-    isEqual(rhs) {
-        if (!this.isCanonical)
-            return this.canonical.isEqual(rhs);
-        rhs = rhs.canonical;
-        if (rhs.isNumber && this.isNumber) {
-            const ce = this.engine;
-            // In general, it is impossible to always prove equality
-            // (Richardson's theorem) but this works often...
-            const diff = ce.add([this, ce.negate(rhs)]).N();
-            if (diff.isZero)
-                return true;
-            if (diff.asFloat !== null && ce.chop(diff.asFloat) === 0)
-                return true;
-            return this.evaluate().isSame(rhs.evaluate());
-        }
-        if (this.domain.isRelationalOperator && rhs.domain.isRelationalOperator) {
-            return this.evaluate().isSame(rhs.evaluate());
-        }
-        return this.isSame(rhs);
+    get isComplex() {
+        return this.domain.isCompatible('ComplexNumber');
+    }
+    get isImaginary() {
+        return this.domain.isCompatible('ImaginaryNumber');
     }
     get sgn() {
+        if (!this.isCanonical)
+            return this.canonical.sgn;
         // @todo: if there is a this.functionDefinition.range, use it
         // @todo if inconclusive, and there is a this.def._sgn, call it
         // @todo: add sgn() function to FunctionDefinition
@@ -18241,81 +18350,14 @@ class BoxedFunction extends AbstractBoxedExpression {
             return +1;
         }
         // @todo: trig functions, geometric functions
-        return null;
-    }
-    *map(fn) {
-        let i = 0;
-        while (i < this._ops.length)
-            yield fn(this._ops[i++]);
-    }
-    get isCanonical() {
-        return this._isCanonical;
-    }
-    set isCanonical(val) {
-        this._isCanonical = val;
-    }
-    apply(fn, head) {
-        const newHead = head ?? this.head;
-        let opsChanged = false;
-        const ops = [];
-        for (const arg of this._ops) {
-            const newArg = fn(arg);
-            if (arg !== newArg)
-                opsChanged = true;
-            ops.push(this.engine.box(newArg));
-        }
-        if (!opsChanged && this.head === newHead)
-            return this;
-        return this.engine.fn(newHead, ops);
-    }
-    get canonical() {
-        if (this.isCanonical || !this.isValid)
-            return this;
-        // 1/ If no definition (i.e. function `g`...), apply canonical to each op
-        const def = this.functionDefinition;
-        if (!def) {
-            const tail = this._ops.map((x) => x.canonical);
-            if (tail.length === this._ops.length &&
-                tail.every((x, i) => this._ops[i] === x)) {
-                // We were already canonical! No need to create a new expression
-                this._isCanonical = true;
-                return this;
-            }
-            return this.engine._fn(this._head, tail);
-        }
-        //
-        // 2/ Get the canonical form of the arguments, accounting for `Hold`,
-        // `ReleaseHold`, `Sequence` and `Symbol`
-        //
-        let tail = canonicalHoldMap(def.name, this._ops, def.hold, def.associative);
-        //
-        // 3/ Apply `canonical` handler
-        //
-        const sig = def.signature;
-        if (sig?.canonical)
-            return sig.canonical(this.engine, tail);
-        //
-        // 4/ Apply `idempotent` and `involution`
-        //
-        if (tail.length === 1 && tail[0].head === this._head) {
-            // f(f(x)) -> x
-            if (def.involution)
-                return tail[0].op1;
-            // f(f(x)) -> f(x)
-            if (def.idempotent)
-                tail = tail[0].ops;
-        }
-        //
-        // 5/ Sort the arguments
-        //
-        if (tail.length > 1 && def.commutative === true)
-            tail = tail.sort(order);
-        if (tail.length === this._ops.length &&
-            tail.every((x, i) => this._ops[i] === x)) {
-            this._isCanonical = true;
-            return this;
-        }
-        return this.engine._fn(this._head, tail);
+        const v = (this.numericValue ?? this.N()).asSmallInteger;
+        if (v === null)
+            return undefined;
+        if (v === 0)
+            return 0;
+        if (v < 0)
+            return -1;
+        return +1;
     }
     simplify(options) {
         //
@@ -18483,14 +18525,75 @@ class BoxedFunction extends AbstractBoxedExpression {
         // @todo
         return null;
     }
-    replace(rules, options) {
-        return replace(this, rules, options);
+}
+function makeCanonicalFunction(ce, head, ops, options) {
+    options ?? (options = {});
+    options.canonical = true;
+    //
+    // Canonicalize the arguments and flatten any sequence
+    //
+    ops = ops.map((x) => x.canonical);
+    ops = flattenSequence(ops);
+    //
+    // Is the head an expression? For example, `['InverseFunction', 'Sin']`
+    //
+    if (typeof head !== 'string')
+        head = head.evaluate().symbol ?? head;
+    if (typeof head !== 'string')
+        return new BoxedFunction(ce, head, ops, options);
+    if (ce.context === null)
+        return new BoxedFunction(ce, head, ops, options);
+    const def = ce.lookupFunction(head, ce.context);
+    if (!def)
+        return new BoxedFunction(ce, head, ops, options);
+    // f(a, f(b, c), d) -> f(a, b, c, d)
+    if (def.associative)
+        ops = flattenOps(ops, head) ?? ops;
+    // Scoped function automatically create a new scope
+    // @todo: this needs to be done when evaluating, not here...
+    if (def.scoped)
+        ce.pushScope();
+    // Apply Sequence, Symbol
+    // this._ops = normalizeList(this._ops, this._def.hold);
+    const sig = def.signature;
+    ops = validateSignature(ce, sig, ops) ?? ops;
+    if (!ops.every((x) => x.isValid)) {
+        if (def.scoped)
+            ce.popScope();
+        return new BoxedFunction(ce, head, ops, { ...options, def });
     }
-    subs(sub) {
-        // Call `fn().canonical` (and not `new BoxedFunction()`) so that the
-        // function may be reconstructed as a canonical expression
-        return this.engine.fn(this._head, this._ops.map((x) => x.subs(sub))).canonical;
+    //
+    // 3/ Apply `canonical` handler
+    //
+    if (sig.canonical) {
+        const fn = sig.canonical(ce, ops);
+        if (fn.isValid && !fn.isCanonical)
+            debugger;
+        console.assert(!fn.isValid || fn.isCanonical);
+        return fn;
+    }
+    //
+    // 4/ No handler, apply idempotent and involution
+    //
+    //
+    // 4/ Apply `idempotent` and `involution`
+    //
+    if (ops.length === 1 && ops[0].head === head) {
+        // f(f(x)) -> x
+        if (def.involution)
+            return ops[0].op1;
+        // f(f(x)) -> f(x)
+        if (def.idempotent)
+            ops = ops[0].ops;
     }
+    //
+    // 5/ Sort the arguments
+    //
+    if (ops.length > 1 && def.commutative === true)
+        ops = ops.sort(order);
+    if (def.scoped)
+        ce.popScope();
+    return new BoxedFunction(ce, head, ops, { ...options, def });
 }
 function lambda(ce, fn, args) {
     // 'fn' is a lambda expression.
@@ -18503,9 +18606,7 @@ function lambda(ce, fn, args) {
         subs[`_${n++}`] = op;
     subs['_'] = subs['_1'];
     // Substitute the arguments in the lambda expression
-    const result = fn.subs(subs);
-    result.bind(ce.context);
-    return result;
+    return fn.subs(subs);
 }
 // export function ungroup(expr: BoxedExpression): BoxedExpression {
 //   if (!expr.ops) return expr;
@@ -18548,20 +18649,9 @@ function holdMap(head, xs, skip, associative, f) {
             else
                 result.push(xs[i]);
             if (y) {
-                if (y.head === 'Sequence') {
-                    if (y.ops)
-                        result.push(...y.ops.map((x) => f(x)).filter((x) => x !== null));
-                }
-                else if (y.domain.literal === 'Symbol') {
-                    const x = f(y.evaluate());
-                    if (x !== null)
-                        result.push(x);
-                }
-                else {
-                    const x = f(y);
-                    if (x !== null)
-                        result.push(x);
-                }
+                const x = f(y);
+                if (x !== null)
+                    result.push(x);
             }
         }
     }
@@ -18581,37 +18671,6 @@ function flattenSequence(xs) {
     }
     return ys;
 }
-// Like `HoldMap` but preserves `Hold` and `ReleaseHold`
-function canonicalHoldMap(head, xs, skip, associative) {
-    if (xs.length === 0)
-        return [];
-    // f(a, f(b, c), d) -> f(a, b, c, d)
-    if (associative)
-        xs = flattenOps(xs, head) ?? xs;
-    //
-    // Apply the hold as necessary
-    //
-    const result = [];
-    for (let i = 0; i < xs.length; i++) {
-        const x = xs[i];
-        if (x.head === 'Hold' ||
-            x.head === 'ReleaseHold' ||
-            !applicable(skip, xs.length - 1, i)) {
-            result.push(x);
-        }
-        else if (x.head === 'Sequence') {
-            if (x.ops)
-                result.push(...x.ops.map((x) => x.canonical));
-        }
-        else if (x.head === 'Symbol' || x.domain.literal === 'Symbol')
-            result.push(x.evaluate());
-        else
-            result.push(x.canonical);
-    }
-    if (associative)
-        return flattenOps(result, head) ?? result;
-    return result;
-}
 function applicable(skip, count, index) {
     if (skip === 'all')
         return false;
@@ -18627,24 +18686,6 @@ function applicable(skip, count, index) {
         return index === count;
     return false;
 }
-function normalizeList(xs, skip) {
-    // Fold 'Sequence'
-    const result = [];
-    for (let i = 0; i < xs.length; i++) {
-        if (applicable(skip, xs.length - 1, i)) {
-            const x = xs[i];
-            if (x.head === 'Sequence')
-                result.push(...(x.ops ?? []));
-            else if (x.head === 'Symbol')
-                result.push(x.evaluate());
-            else
-                result.push(x);
-        }
-        else
-            result.push(xs[i]);
-    }
-    return result;
-}
 /** Return `null` if the `ops` match the sig. Otherwise, return an array
  * of expressions indicating the mismatched arguments.
  *
@@ -18974,6 +19015,12 @@ class BoxedNumber extends AbstractBoxedExpression {
     set isCanonical(val) {
         this._isCanonical = val;
     }
+    get complexity() {
+        return 1;
+    }
+    get value() {
+        return this;
+    }
     get numericValue() {
         if (!Array.isArray(this._value))
             return this;
@@ -19007,8 +19054,7 @@ class BoxedNumber extends AbstractBoxedExpression {
                     return Number.POSITIVE_INFINITY;
                 return Number.NEGATIVE_INFINITY;
             }
-            if (isInMachineRange(this._value))
-                return this._value.toNumber();
+            return this._value.toNumber();
         }
         if (Array.isArray(this._value))
             return this._value[0] / this._value[1];
@@ -19644,7 +19690,7 @@ function box(ce, expr) {
         if ('fn' in expr) {
             if (typeof expr.fn[0] === 'string')
                 return boxFunction(ce, expr.fn[0], expr.fn.slice(1), metadata);
-            return new BoxedFunction(ce, box(ce, expr.fn[0]), expr.fn.slice(1).map((x) => box(ce, x)), metadata);
+            return new BoxedFunction(ce, box(ce, expr.fn[0]), expr.fn.slice(1).map((x) => box(ce, x)), { metadata });
         }
         if ('str' in expr)
             return new BoxedString(ce, expr.str, metadata);
@@ -19672,7 +19718,7 @@ function boxNumber(ce, num, metadata) {
     if (Array.isArray(num)) {
         if (num.length !== 2)
             throw new Error('Array argument to boxNumber() should be two integers');
-        const [n, d] = num;
+        let [n, d] = num;
         if (typeof n !== 'number' || typeof d !== 'number')
             throw new Error('Array argument to boxNumber() should be two integers');
         if (!Number.isInteger(n) || !Number.isInteger(d))
@@ -19822,7 +19868,9 @@ function boxFunction(ce, head, ops, metadata) {
     // Hold
     //
     if (head === 'Hold') {
-        const result = new BoxedFunction(ce, 'Hold', [boxHold(ce, ops[0])], metadata);
+        const result = new BoxedFunction(ce, 'Hold', [boxHold(ce, ops[0])], {
+            metadata,
+        });
         // Hold is always canonical
         result.isCanonical = true;
         return result;
@@ -19859,7 +19907,9 @@ function boxFunction(ce, head, ops, metadata) {
                 ];
                 if (n !== null && d !== null)
                     return ce.number([n, d], metadata);
-                return new BoxedFunction(ce, 'Rational', [ops[0], ops[1]], metadata);
+                return new BoxedFunction(ce, 'Rational', [ops[0], ops[1]], {
+                    metadata,
+                });
             }
         }
         else {
@@ -19869,7 +19919,9 @@ function boxFunction(ce, head, ops, metadata) {
             if (n?.isInteger() && d?.isInteger()) {
                 if (isInMachineRange(n) && isInMachineRange(d))
                     return ce.number([n.toNumber(), d.toNumber()], metadata);
-                return new BoxedFunction(ce, 'Rational', [ce.box(op1), ce.box(op2)], metadata);
+                return new BoxedFunction(ce, 'Rational', [ce.box(op1), ce.box(op2)], {
+                    metadata,
+                });
             }
         }
         head = 'Divide';
@@ -19927,14 +19979,16 @@ function boxFunction(ce, head, ops, metadata) {
             return ce.error('expected-argument', "'Single");
         if (ops.length > 1)
             return ce.error('unexpected-argument', "'Single");
-        return new BoxedFunction(ce, 'Tuple', [ce.box(ops[0])], metadata);
+        return new BoxedFunction(ce, 'Tuple', [ce.box(ops[0])], { metadata });
     }
     if (head === 'Pair') {
         if (ops.length < 2)
             return ce.error('expected-argument', "'Pair");
         if (ops.length > 2)
             return ce.error('unexpected-argument', "'Pair");
-        return new BoxedFunction(ce, 'Tuple', [ce.box(ops[0]), ce.box(ops[1])], metadata);
+        return new BoxedFunction(ce, 'Tuple', [ce.box(ops[0]), ce.box(ops[1])], {
+            metadata,
+        });
     }
     // KeyValuePair is not normalized to Tuple
     if (head === 'KeyValuePair') {
@@ -19942,14 +19996,14 @@ function boxFunction(ce, head, ops, metadata) {
             return ce.error('expected-argument', "'KeyValuePair");
         if (ops.length > 2)
             return ce.error('unexpected-argument', "'KeyValuePair");
-        return new BoxedFunction(ce, 'KeyValuePair', [ce.box(ops[0]), ce.box(ops[1])], metadata);
+        return new BoxedFunction(ce, 'KeyValuePair', [ce.box(ops[0]), ce.box(ops[1])], { metadata });
     }
     if (head === 'Triple') {
         if (ops.length < 3)
             return ce.error('expected-argument', "'Triple");
         if (ops.length > 3)
             return ce.error('unexpected-argument', "'Triple");
-        return new BoxedFunction(ce, 'Tuple', ops.map((x) => ce.box(x)), metadata);
+        return new BoxedFunction(ce, 'Tuple', ops.map((x) => ce.box(x)), { metadata });
     }
     //
     // Dictionary
@@ -19978,7 +20032,7 @@ function boxFunction(ce, head, ops, metadata) {
         }
         return new BoxedDictionary(ce, dict, metadata);
     }
-    return new BoxedFunction(ce, head, ops.map((x) => box(ce, x)), metadata);
+    return new BoxedFunction(ce, head, ops.map((x) => box(ce, x)), { metadata });
 }
 function asString(expr) {
     if (typeof expr === 'string')
@@ -20789,10 +20843,14 @@ function square(ce, base) {
 function processPower(ce, base, exponent, mode) {
     if (mode !== 'simplify' && base.isLiteral && exponent.isLiteral) {
         if (mode === 'N' || !base.isInteger) {
-            if (base.complexValue)
+            if (base.complexValue) {
                 return ce.number(base.complexValue.pow(exponent.complexValue ?? exponent.asFloat ?? NaN));
-            if (exponent.complexValue && base.asFloat !== null)
-                return ce.number(ce.complex(base.asFloat).pow(exponent.complexValue));
+            }
+            if (exponent.complexValue) {
+                const b = base.asFloat ?? base.decimalValue?.toNumber() ?? null;
+                if (b !== null)
+                    return ce.number(ce.complex(b).pow(exponent.complexValue));
+            }
             if (base.decimalValue) {
                 return ce.number(base.decimalValue.pow(exponent.decimalValue ?? exponent.asFloat));
             }
@@ -20929,15 +20987,25 @@ function evalMultiply(ce, ops, mode = 'evaluate') {
                 product.addTerm(arg);
         }
     }
-    if (!complexAllowed(ce) && complexProduct.im !== 0)
-        return ce._NAN;
+    if (complexProduct.im !== 0) {
+        if (!complexAllowed(ce))
+            return ce._NAN;
+        // We have an imaginary number: fold Decimal into machine numbers
+        machineProduct *= decimalProduct.toNumber();
+        decimalProduct = ce._DECIMAL_ONE;
+        numer *= decimalNumer.toNumber();
+        denom *= decimalDenom.toNumber();
+        decimalNumer = ce._DECIMAL_ONE;
+        decimalDenom = ce._DECIMAL_ONE;
+    }
     if (decimalDenom.eq(ce._DECIMAL_ONE) && isInMachineRange(decimalNumer)) {
         numer = denom * decimalNumer.toNumber();
         decimalNumer = ce._DECIMAL_ONE;
     }
-    if (preferDecimal(ce) ||
-        !decimalProduct.eq(ce._DECIMAL_ONE) ||
-        !(decimalNumer.eq(ce._DECIMAL_ONE) && decimalDenom.eq(ce._DECIMAL_ONE))) {
+    if (complexProduct.im === 0 &&
+        (preferDecimal(ce) ||
+            !decimalProduct.eq(ce._DECIMAL_ONE) ||
+            !(decimalNumer.eq(ce._DECIMAL_ONE) && decimalDenom.eq(ce._DECIMAL_ONE)))) {
         // Fold into decimal
         let d = decimalProduct.mul(machineProduct);
         if (mode === 'N') {
@@ -21179,7 +21247,7 @@ function canonicalDivide(ce, op1, op2) {
             return canonicalNegate(op1);
         const [n, d] = [op1.asSmallInteger, op2.asSmallInteger];
         if (n !== null && d !== null && d !== 0)
-            return ce.number([n, d]);
+            return ce.number(reducedRational$1([n, d]));
         if (op1.isInteger && op2.isInteger) {
             // eslint-disable-next-line prefer-const
             let [nSign, dn] = makePositive(op1);
@@ -21476,7 +21544,7 @@ const ARITHMETIC_LIBRARY = [
                 wikidata: 'Q204037',
                 complexity: 4000,
                 signature: {
-                    domain: ['Function', 'Number', 'Number', 'Number'],
+                    domain: ['Function', 'Number', 'Number'],
                     N: (ce, ops) => {
                         if (ops[0].decimalValue)
                             return ce.number(ops[0].decimalValue.log());
@@ -21494,7 +21562,7 @@ const ARITHMETIC_LIBRARY = [
                 wikidata: 'Q11197',
                 complexity: 4100,
                 signature: {
-                    domain: ['Function', 'Number', 'Number', 'Number'],
+                    domain: ['Function', 'Number', ['Maybe', 'Number'], 'Number'],
                     N: (ce, ops) => {
                         const exponent = ops[0];
                         const base = ops[1] ?? ce.number(10);
@@ -21572,7 +21640,7 @@ const ARITHMETIC_LIBRARY = [
                         let result = undefined;
                         const rest = [];
                         for (const op of ops) {
-                            if (!op.isNumber || op.value === undefined)
+                            if (!op.isNumber || op.numericValue === undefined)
                                 rest.push(op);
                             else if (!result || op.isGreater(result))
                                 result = op;
@@ -21602,7 +21670,7 @@ const ARITHMETIC_LIBRARY = [
                         let result = undefined;
                         const rest = [];
                         for (const op of ops) {
-                            if (!op.isNumber || op.value === undefined)
+                            if (!op.isNumber || op.numericValue === undefined)
                                 rest.push(op);
                             else if (!result || op.isLess(result))
                                 result = op;
@@ -21737,11 +21805,13 @@ const ARITHMETIC_LIBRARY = [
                                 return ce.number([n, d]);
                             return undefined;
                         }
+                        //
                         // If there is a single argument, i.e. `['Rational', 'Pi']`
                         // the function evaluates to a rational expression of the argument
-                        const f = ops[0].asFloat ?? ops[0].decimalValue?.toNumber() ?? null;
+                        //
+                        const f = ops[0].N().asFloat ?? null;
                         if (f === null)
-                            return ops[0];
+                            return undefined;
                         const r = rationalize(f);
                         if (typeof r === 'number')
                             return ce.number(r);
@@ -21944,10 +22014,8 @@ const ARITHMETIC_LIBRARY = [
                             }
                             // Maybe a compound symbol
                             let sub = op2.string ?? op2.symbol;
-                            if (!sub) {
-                                if (op2.asSmallInteger !== null)
-                                    sub = op2.asSmallInteger.toString();
-                            }
+                            if (!sub && op2.isLiteral && op2.asSmallInteger !== null)
+                                sub = op2.asSmallInteger.toString();
                             if (sub)
                                 return ce.symbol(op1.symbol + '_' + sub);
                         }
@@ -22656,29 +22724,22 @@ const CORE_LIBRARY = [
                 threadable: true,
                 hold: 'all',
                 signature: {
-                    domain: ['Function', ['Sequence', 'Anything'], 'Symbol'],
-                    evaluate: (ce, ops) => {
+                    domain: ['Function', ['Sequence', 'Anything'], 'Anything'],
+                    canonical: (ce, ops) => {
                         if (ops.length === 0)
                             return ce.symbol('Nothing');
-                        const args = ops;
-                        const arg = args
-                            .map((x) => {
-                            const symName = x.symbol;
-                            if (symName !== null)
-                                return symName;
-                            const stringValue = arg.string;
-                            if (stringValue !== null)
-                                return stringValue;
-                            const numValue = arg.smallIntegerValue;
-                            if (numValue !== null)
-                                return numValue.toString();
-                            return '';
-                        })
+                        const arg = ops
+                            .map((x) => x.symbol ??
+                            x.string ??
+                            (x.isLiteral ? x.asSmallInteger?.toString() : null) ??
+                            '')
                             .join('');
                         if (arg.length > 0)
                             return ce.symbol(arg);
                         return ce.symbol('Nothing');
                     },
+                    // Note: a `["Symbol"]` expression is never evaluated, it gets
+                    // transformed into something else (a symbol) during canonicalization
                 },
             },
             {
@@ -24622,7 +24683,7 @@ class BoxedSymbolDefinitionImpl {
         this._domain = null;
     }
     bind() {
-        this._value = undefined;
+        this._value = null;
         // this._domain = this._domain?._purge();
         const def = this._def;
         const ce = this._engine;
@@ -24650,10 +24711,10 @@ class BoxedSymbolDefinitionImpl {
             // unit: def.unit ? ce.box(def.unit) : undefined,
         });
         //
-        // 1/ Is it a number?
+        // 1/ Is it defined as a simple machine number?
         //
         if ('value' in def && typeof def.value === 'number') {
-            // If the dictionary entry is provided as a number, assume it's a
+            // If the definition entry is provided as a number, assume it's a
             // variable, and infer its domain based on its value.
             const value = ce.number(def.value);
             let domain;
@@ -24672,12 +24733,15 @@ class BoxedSymbolDefinitionImpl {
         //
         // 2/ It's a full definition with no value or a non-numeric value
         //
-        let value;
-        if (def.hold === false) {
-            value = this.value;
-            if (!value)
-                throw new Error(`Symbol definition "${def.name}": Expected a value "hold=false" `);
-        }
+        let value = undefined;
+        if (isLatexString(def.value))
+            value = ce.parse(def.value);
+        else if (typeof def.value === 'function')
+            value = ce.box(def.value(ce) ?? 'Undefined');
+        else if (def.value)
+            value = ce.box(def.value);
+        if (!value && def.hold === false)
+            throw new Error(`Symbol definition "${def.name}": Expected a value when "hold=false" `);
         value = value?.canonical;
         //
         // If there is a domain specified in the definition, and it is compatible
@@ -24695,38 +24759,27 @@ class BoxedSymbolDefinitionImpl {
             domain = defDomain;
         else
             domain = value?.domain ?? ce.defaultDomain;
-        if (!value) {
-            this._value = undefined;
-            this._domain = domain;
-            this.setProps(domainToFlags(domain));
-            this.setProps(result);
-            return;
-        }
         this._value = value;
         this._domain = domain;
-        this.setProps(valueToFlags(value));
+        if (value)
+            this.setProps(valueToFlags(value));
         this.setProps(domainToFlags(domain));
         this.setProps(result);
     }
     get value() {
         if (this._value === null)
             this.bind();
-        if (this._value === undefined) {
-            if (isLatexString(this._def.value))
-                this._value = this._engine.parse(this._def.value);
-            else if (typeof this._def.value === 'function')
-                this._value = this._engine.box(this._def.value(this._engine) ?? 'Undefined');
-            else if (this._def.value)
-                this._value = this._engine.box(this._def.value);
-        }
         return this._value ?? undefined;
     }
     set value(val) {
+        // Need to bind first to check, e.g. `this.constant`
+        if (this._value === null)
+            this.bind();
         if (this.constant)
             throw new Error(`The value of the constant "${this.name}" cannot be changed`);
         if (typeof val === 'number')
             val = this._engine.box(val);
-        this._value = val;
+        this._value = val ?? null;
         if (val)
             this.setProps(valueToFlags(val));
     }
@@ -25766,26 +25819,26 @@ class BoxedSymbol extends AbstractBoxedExpression {
         return;
     }
     get canonical() {
-        if (this.symbolDefinition?.hold === false)
-            return (this.symbolDefinition.value?.value ??
-                this.symbolDefinition.value ??
-                this);
-        return this;
+        if (this.symbolDefinition?.hold === true)
+            return this;
+        return (this.symbolDefinition?.value?.value ??
+            this.symbolDefinition?.value ??
+            this);
     }
     get wikidata() {
-        return this._wikidata ?? this.baseDefinition?.wikidata ?? '';
+        return this._wikidata ?? this.baseDefinition?.wikidata ?? undefined;
     }
     get description() {
         if (!this.baseDefinition)
-            return [];
+            return undefined;
         if (!this.baseDefinition.description)
-            return [];
+            return undefined;
         if (typeof this.baseDefinition.description === 'string')
             return [this.baseDefinition.description];
         return this.baseDefinition.description;
     }
     get url() {
-        return this.baseDefinition?.url ?? '';
+        return this.baseDefinition?.url ?? undefined;
     }
     get complexity() {
         return 7;
@@ -25865,7 +25918,7 @@ class BoxedSymbol extends AbstractBoxedExpression {
         }
     }
     get value() {
-        return this.symbolDefinition?.value;
+        return this.symbolDefinition?.value ?? this;
     }
     set value(value) {
         // Symbols starting with `_` are wildcards and never have an associated
@@ -25912,7 +25965,7 @@ class BoxedSymbol extends AbstractBoxedExpression {
         }
     }
     get numericValue() {
-        return this.symbolDefinition?.value?.numericValue;
+        return this.symbolDefinition?.value?.numericValue ?? undefined;
     }
     get domain() {
         if (this.functionDefinition)
@@ -25949,7 +26002,7 @@ class BoxedSymbol extends AbstractBoxedExpression {
     get explicitDomain() {
         if (this.functionDefinition)
             return this.engine.domain('Function');
-        return this.symbolDefinition?.domain ?? null;
+        return this.symbolDefinition?.domain ?? undefined;
     }
     get json() {
         return serializeJsonSymbol(this.engine, this._name, {
@@ -25960,17 +26013,23 @@ class BoxedSymbol extends AbstractBoxedExpression {
     get sgn() {
         // If available, use the value associated with this symbol.
         // Note that `null` is an acceptable and valid value
-        const s = this.value?.sgn;
-        if (s !== undefined)
-            return s;
+        const v = this.numericValue;
+        if (v && v !== this) {
+            const s = v.sgn;
+            if (s !== undefined)
+                return s;
+        }
         // We didn't get a definitive answer from the value
         // of this symbol. Check flags.
-        if (this.symbolDefinition?.zero === true)
-            return 0;
-        if (this.symbolDefinition?.positive === true)
-            return 1;
-        if (this.symbolDefinition?.negative === true)
-            return -1;
+        const def = this.symbolDefinition;
+        if (def) {
+            if (def.zero === true)
+                return 0;
+            if (def.positive === true)
+                return 1;
+            if (def.negative === true)
+                return -1;
+        }
         return undefined;
     }
     has(x) {
@@ -25993,15 +26052,22 @@ class BoxedSymbol extends AbstractBoxedExpression {
         return null;
     }
     isEqual(rhs) {
+        if (!this.isCanonical)
+            return this.canonical.isEqual(rhs);
+        rhs = rhs.canonical;
+        //  Boxed Identity
         if (this === rhs)
             return true;
         // Idempotency ('x' = 'x')
         if (rhs.symbol !== null)
             return rhs.symbol === this._name;
         // Mathematical/numeric equality
-        const val = this.symbolDefinition?.value;
-        if (val)
-            return val.isEqual(rhs);
+        const lhsVal = this.symbolDefinition?.value?.numericValue;
+        if (lhsVal) {
+            const rhsVal = rhs.numericValue;
+            if (rhsVal)
+                return lhsVal.isEqual(rhsVal);
+        }
         if (rhs.isZero) {
             if (this.isZero)
                 return true;
@@ -26012,6 +26078,8 @@ class BoxedSymbol extends AbstractBoxedExpression {
             return false;
         // @todo could test other contradictory properties: prime vs composite, etc...
         // Direct assumptions
+        if (this.engine.ask(['Equal', this, rhs]).length > 0)
+            return true;
         if (this.engine.ask(['NotEqual', this, rhs]).length > 0)
             return false;
         //@todo: could use range
@@ -26982,15 +27050,22 @@ class ComputeEngine {
             return this.divide(ops[0] ?? this.error('missing'), ops[1] ?? this.error('missing'), metadata);
         if (head === 'Power')
             return this.power(ops[0] ?? this.error('missing'), ops[1] ?? this.error('missing'), metadata);
-        const result = new BoxedFunction(this, head, ops, metadata);
-        return result.canonical;
+        return makeCanonicalFunction(this, head, ops, { metadata });
     }
     /** @internal */
     _fn(head, ops, metadata) {
         // if (!ops.every((x) => x.isCanonical))    debugger;
-        const result = new BoxedFunction(this, head, ops, metadata);
-        result.isCanonical = true;
-        return result;
+        // return makeCanonicalFunction(this, head, ops, {
+        //   metadata,
+        //   canonical: true,
+        // });
+        return new BoxedFunction(this, head, ops, {
+            metadata,
+            canonical: true,
+            def: typeof head === 'string' && this.context
+                ? this.lookupFunction(head, this.context)
+                : undefined,
+        });
     }
     error(message, where) {
         if (where && Array.isArray(where) && where[0] === 'Latex') {
@@ -27321,6 +27396,6 @@ class ComputeEngine {
 }
 
 // This file is the root of the `compute-engine` package
-const version = '0.7.0';
+const version = '0.8.0';
 
 export { ComputeEngine, getVars, isEnvironmentEntry, isFunctionEntry, isInfixEntry, isMatchfixEntry, isPostfixEntry, isPrefixEntry, isSymbolEntry, version };