@cortex-js/compute-engine 0.11.0 → 0.12.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.11.0 */
+/** CortexJS Compute Engine 0.12.1 */
 /** @internal */
 function isSymbolEntry(entry) {
     return !('kind' in entry) || entry.kind === 'symbol';
@@ -6801,6 +6801,17 @@ const DEFINITIONS_ALGEBRA = [
     },
 ];
 
+function isNumberExpression(expr) {
+    if (expr === null)
+        return false;
+    if (typeof expr === 'number')
+        return true;
+    if (isNumberObject(expr))
+        return true;
+    if (typeof expr === 'string' && /^[+-]?[0-9]/.test(expr))
+        return true;
+    return false;
+}
 function isNumberObject(expr) {
     return expr !== null && typeof expr === 'object' && 'num' in expr;
 }
@@ -7158,7 +7169,7 @@ function countLeaves(expr) {
         return 0;
     if (typeof expr === 'number' || typeof expr === 'string')
         return 1;
-    if (isNumberObject(expr) || isSymbolObject(expr) || isStringObject(expr))
+    if (isNumberExpression(expr) || isSymbolObject(expr) || isStringObject(expr))
         return 1;
     if (Array.isArray(expr))
         return countFunctionLeaves(expr);
@@ -7462,7 +7473,7 @@ function serializeMultiply(serializer, expr) {
         //
         // 1. Should the terms be separated by an explicit 'Multiply'?
         //
-        if (typeof arg === 'number' || isNumberObject(arg)) {
+        if (isNumberExpression(arg)) {
             term = serializer.serialize(arg);
             if (term === '-1' && !result) {
                 result = '';
@@ -8349,6 +8360,26 @@ const DEFINITIONS_CORE = [
             return `\\mathbf{${serializer.serialize(op(expr, 1))}}`;
         },
     },
+    {
+        trigger: ['\\mathtip'],
+        parse: (parser) => {
+            const op1 = parser.matchRequiredLatexArgument();
+            parser.matchRequiredLatexArgument();
+            return op1;
+        },
+    },
+    {
+        trigger: ['\\texttip'],
+        parse: (parser) => {
+            const op1 = parser.matchRequiredLatexArgument();
+            parser.matchRequiredLatexArgument();
+            return op1;
+        },
+    },
+    {
+        trigger: ['\\error'],
+        parse: (parser) => parser.matchRequiredLatexArgument(),
+    },
     {
         name: 'Error',
         serialize: (serializer, expr) => {
@@ -8360,6 +8391,9 @@ const DEFINITIONS_CORE = [
             if (code === 'incompatible-domain') {
                 return `\\mathtip{\\error{${where}}}{\\in ${serializer.serialize(op(op1, 3))}\\notin ${serializer.serialize(op(op1, 2))}}`;
             }
+            if (code === 'missing') {
+                return `\\mathtip{\\error{${where}}}{${serializer.serialize(op(op1, 2))}\\text{ missing}}`;
+            }
             if (typeof code === 'string')
                 return `\\error{${where}}`;
             return `\\error{${where}}`;
@@ -12923,7 +12957,7 @@ class _Parser {
 // - 123.456 = significand
 // - 123 = wholePart
 // - 456 = fractionalPart
-// - 79 = exponent
+// - 78 = exponent
 //
 // Avoid using mantissa which has several definitions and is ambiguous.
 /**
@@ -12934,17 +12968,19 @@ class _Parser {
 function formatFractionalPart(m, options) {
     const originalLength = m.length;
     const originalM = m;
-    // The last digit may have been rounded off, if it exceeds the precision,
-    // which could throw off the repeating pattern detection. Ignore it.
-    m = m.slice(0, -1);
-    for (let i = 0; i < m.length - 16; i++) {
-        // Offset is the part of the fractional part that is not repeating
-        const offset = m.substring(0, i);
-        // Try to find a repeating pattern of length j
-        for (let j = 0; j < 17; j++) {
-            const cycle = m.substring(i, i + j + 1);
-            const times = Math.floor((m.length - offset.length) / cycle.length);
-            if (times > 1) {
+    if (options.beginRepeatingDigits && options.endRepeatingDigits) {
+        // The last digit may have been rounded off, if it exceeds the precision,
+        // which could throw off the repeating pattern detection. Ignore it.
+        m = m.slice(0, -1);
+        for (let i = 0; i < m.length - 16; i++) {
+            // Offset is the part of the fractional part that is not repeating
+            const offset = m.substring(0, i);
+            // Try to find a repeating pattern of length j
+            for (let j = 0; j < 17; j++) {
+                const cycle = m.substring(i, i + j + 1);
+                const times = Math.floor((m.length - offset.length) / cycle.length);
+                if (times <= 3)
+                    break;
                 if ((offset + cycle.repeat(times + 1)).startsWith(m)) {
                     // We've found a repeating pattern!
                     if (cycle === '0') {
@@ -12965,9 +13001,8 @@ function formatFractionalPart(m, options) {
     // Display a truncation marker.
     const extraDigits = originalLength > options.precision - 1;
     m = originalM;
-    if (extraDigits) {
+    if (extraDigits)
         m = m.substring(0, options.precision - 1);
-    }
     // Insert group separators if necessary
     if (options.groupSeparator) {
         m = m.replace(/(\d{3})/g, '$1' + options.groupSeparator);
@@ -13012,9 +13047,12 @@ function serializeNumber(expr, options) {
             return options.negativeInfinity;
         else if (Number.isNaN(num))
             return options.notANumber;
+        let result = undefined;
         if (options.notation === 'engineering')
-            return serializeEngineeringNotationNumber(num, options);
-        return serializeAutoNotationNumber(num.toString(), options);
+            result = serializeScientificNotationNumber(num.toExponential(), options, 3);
+        else if (options.notation === 'scientific')
+            result = serializeScientificNotationNumber(num.toExponential(), options);
+        return result ?? serializeAutoNotationNumber(num.toString(), options);
     }
     num = num.toLowerCase().replace(/[\u0009-\u000d\u0020\u00a0]/g, '');
     if (num === 'infinity' || num === '+infinity')
@@ -13027,6 +13065,7 @@ function serializeNumber(expr, options) {
         return '';
     num = num.replace(/[nd]$/, '');
     // Do we have repeating digits?
+    // If so, "unrepeat" (expand) them
     if (/\([0-9]+\)/.test(num)) {
         const [_, body, repeat, trail] = num.match(/(.+)\(([0-9]+)\)(.*)$/) ?? [];
         num =
@@ -13046,128 +13085,130 @@ function serializeNumber(expr, options) {
     while (num[0] === '0')
         num = num.substring(1);
     if (num.length === 0)
-        return sign + '0';
-    if (num[0] === '.')
-        num = '0' + num;
-    let exponent = '';
-    if (num.indexOf('.') >= 0) {
-        const m = num.match(/(\d*)\.(\d*)([e|E]([-+]?[0-9]*))?/);
-        if (!m)
-            return '';
-        const base = m[1];
-        const fractionalPart = m[2];
-        exponent = m[4] ?? '';
-        if (base === '0') {
-            let p = 0; // Index of the first non-zero digit after the decimal
-            while (fractionalPart[p] === '0' && p < fractionalPart.length)
-                p += 1;
-            let r = '';
-            if (p <= 4) {
-                r = '0' + options.decimalMarker;
-                r += fractionalPart.substring(0, p);
-                r += formatFractionalPart(num.substring(r.length), options);
-            }
-            else if (p + 1 >= options.precision) {
-                r = '0';
-                sign = '';
+        num = sign + '0';
+    else if (num[0] === '.')
+        num = sign + '0' + num;
+    let result = undefined;
+    if (options.notation === 'engineering')
+        result = serializeScientificNotationNumber(num, options, 3);
+    else if (options.notation === 'scientific')
+        result = serializeScientificNotationNumber(num, options);
+    return sign + (result ?? serializeAutoNotationNumber(num, options));
+}
+/**
+ * Scientific notation has:
+ * - a whole part [1..9]
+ * - an optional fractional part (many digits)
+ * - an optional exponent
+ * @param valString
+ * @param options
+ * @returns
+ */
+function serializeScientificNotationNumber(valString, options, expMultiple = 1) {
+    // For '7' returns '7e+0'
+    let m = valString.match(/^(.*)[e|E]([-+]?[0-9]+)$/);
+    if (!m) {
+        // Valstring wasn't in exponential form, convert it.
+        // Remove the sign
+        let sign = '';
+        if (valString[0] === '-') {
+            sign = '-';
+            valString = valString.substring(1);
+        }
+        else if (valString[0] === '+') {
+            valString = valString.substring(1);
+        }
+        if (valString.indexOf('.') < 0) {
+            if (valString.length === 1) {
+                valString = sign + valString + 'e+0';
             }
             else {
-                r = num[p];
-                const f = formatFractionalPart(num.substring(p + 1), options);
-                if (f) {
-                    r += options.decimalMarker + f;
-                }
+                // A long integer, convert to exponential form
+                valString =
+                    sign +
+                        valString[0] +
+                        '.' +
+                        valString.slice(1) +
+                        'e+' +
+                        (valString.length - 1).toString();
             }
-            if (r !== '0') {
-                if (num.length - 1 > options.precision &&
-                    !(options.endRepeatingDigits && r.endsWith(options.endRepeatingDigits)) &&
-                    options.truncationMarker &&
-                    !r.endsWith(options.truncationMarker)) {
-                    r += options.truncationMarker;
-                }
-                if (p > 4) {
-                    r +=
-                        options.exponentProduct +
-                            formatExponent((1 - p).toString(), options);
-                }
-            }
-            num = r;
         }
         else {
-            num = base.replace(/\B(?=(\d{3})+(?!\d))/g, options.groupSeparator);
-            const f = formatFractionalPart(fractionalPart, options);
-            if (f) {
-                num += options.decimalMarker + f;
-                // if (num.length - 1 > config.precision && !num.endsWith('}') && !num.endsWith('\\ldots')) {
-                //     num += '\\ldots';
-                // }
-            }
-        }
-    }
-    else if (num.length > options.precision) {
-        const len = num.length;
-        if (len > options.avoidExponentsInRange[1]) {
-            let r = num[0];
-            const f = formatFractionalPart(num.substring(1), options);
-            if (f) {
-                r += options.decimalMarker + f;
-                if (options.truncationMarker && !r.endsWith(options.truncationMarker)) {
-                    if (options.endRepeatingDigits &&
-                        !r.endsWith(options.endRepeatingDigits)) {
-                        r += options.truncationMarker;
-                    }
-                }
-            }
-            if (r !== '1') {
-                r += options.exponentProduct;
+            // A decimal number, convert to exponential form
+            // eslint-disable-next-line prefer-const
+            let [_, whole, fraction] = valString.match(/^(.*)\.(.*)$/);
+            if (!fraction)
+                fraction = '';
+            while (whole.startsWith('0'))
+                whole = whole.substring(1);
+            if (!whole) {
+                // .123 -> 0.123e+0
+                // .0123 -> 0.0123e+0
+                valString = sign + '0.' + fraction + 'e+0';
             }
             else {
-                r = '';
+                // 1.234  -> 1.234e+0
+                // 12.345 -> 1.2345e+1
+                valString =
+                    sign +
+                        whole[0] +
+                        '.' +
+                        whole.slice(1) +
+                        fraction +
+                        'e+' +
+                        (whole.length - 1).toString();
             }
-            num = r + formatExponent((len - 1).toString(), options);
         }
+        m = valString.match(/^(.*)[e|E]([-+]?[0-9]+)$/);
+    }
+    console.assert(m);
+    if (!m)
+        return serializeAutoNotationNumber(valString, options);
+    let exponent = parseInt(m[2]);
+    let mantissa = m[1];
+    if (Math.abs(exponent) % expMultiple !== 0) {
+        // Need to adjust the exponent and values, e.g. for engineering notation
+        const adjust = exponent > 0
+            ? exponent % expMultiple
+            : -((expMultiple + exponent) % expMultiple);
+        exponent = exponent >= 0 ? exponent - adjust : exponent + adjust;
+        // Don't use numeric operations, which may introduce artifacting
+        // eslint-disable-next-line prefer-const
+        let [_, whole, fraction] = mantissa.match(/^(.*)\.(.*)$/) ?? [
+            '',
+            mantissa,
+            '',
+        ];
+        mantissa =
+            whole +
+                (fraction + '00000000000000000').slice(0, Math.abs(adjust)) +
+                '.' +
+                fraction.slice(Math.abs(adjust));
+    }
+    // Is the exponent in a range to be avoided?
+    const avoid = options.avoidExponentsInRange;
+    if (avoid && exponent >= avoid[0] && exponent <= avoid[1])
+        return undefined;
+    let fractionalPart = '';
+    let wholePart = mantissa;
+    m = wholePart.match(/^(.*)\.(.*)$/);
+    if (m) {
+        wholePart = m[1];
+        fractionalPart = m[2];
     }
-    else {
-        const m = num.match(/([0-9]*)\.?([0-9]*)([e|E]([-+]?[0-9]+))?/);
-        if (m) {
-            num = m[1];
-            if (m[2])
-                num += options.decimalMarker + m[2];
-            exponent = m[4] ?? '';
-        }
-        num = num.replace(/\B(?=(\d{3})+(?!\d))/g, options.groupSeparator);
-    }
-    const exponentString = formatExponent(exponent, options);
-    if (num === '1' && exponentString)
-        return sign + exponentString;
-    if (exponentString)
-        num = num + options.exponentProduct + exponentString;
-    return sign + num;
-}
-function serializeEngineeringNotationNumber(value, options) {
-    if (value === 0)
-        return '0';
-    // Ensure the exponent is a multiple of 3
-    const y = Math.abs(value);
-    let exponent = Math.round(Math.log10(y));
-    exponent = exponent - (exponent % 3);
-    if (y > Math.pow(10, options.avoidExponentsInRange[0]) &&
-        y < Math.pow(10, options.avoidExponentsInRange[1]))
-        exponent = 0;
-    const significand = y / Math.pow(10, exponent);
-    let significandString = '';
-    const m = significand.toString().match(/^(.*)\.(.*)$/);
-    if (m?.[1] && m[2]) {
-        significandString = m[1] + options.decimalMarker + m[2];
-    }
+    const expString = exponent !== 0 ? formatExponent(Number(exponent).toString(), options) : '';
     if (options.groupSeparator) {
-        significandString = formatFractionalPart(significand.toExponential(), options);
-    }
-    let exponentString = '';
-    if (exponent !== 0) {
-        exponentString = formatExponent(exponent.toString(), options);
+        wholePart = wholePart.replace(/\B(?=(\d{3})+(?!\d))/g, options.groupSeparator);
+        fractionalPart = formatFractionalPart(fractionalPart, options);
     }
-    return (value < 0 ? '-' : '') + significandString + exponentString;
+    if (fractionalPart)
+        fractionalPart = options.decimalMarker + fractionalPart;
+    // @todo: does not respect the options.precision option
+    if (!expString)
+        return wholePart + fractionalPart;
+    if (wholePart === '1' && !fractionalPart)
+        return expString;
+    return wholePart + fractionalPart + options.exponentProduct + expString;
 }
 function serializeAutoNotationNumber(valString, options) {
     let m = valString.match(/^(.*)[e|E]([-+]?[0-9]+)$/i);
@@ -13322,9 +13363,7 @@ class Serializer {
         const exprStr = this.serialize(expr);
         if (head(expr) === 'Delimiter' && nops(expr) === 1)
             return exprStr;
-        if (typeof expr !== 'number' &&
-            !isNumberObject(expr) &&
-            !/(^(.|\\[a-zA-Z*]+))$/.test(exprStr)) {
+        if (!isNumberExpression(expr) && !/(^(.|\\[a-zA-Z*]+))$/.test(exprStr)) {
             // It's a long expression, wrap it
             return this.wrapString(exprStr, this.options.groupStyle(expr, this.level + 1));
         }
@@ -13970,8 +14009,10 @@ function primeFactors$1(n) {
             }
         }
     }
-    console.assert(result[n] === undefined);
-    result[n] = 1;
+    if (result[n] !== undefined)
+        result[n] += 1;
+    else
+        result[n] = 1;
     return result;
 }
 /* @todo Consider https://cp-algorithms.com/algebra/factorization.html */
@@ -14140,7 +14181,7 @@ function asFloat(expr) {
         const [n, d] = num;
         if (typeof n === 'number' && typeof d === 'number')
             return n / d;
-        return n.div(d).toNumber();
+        return Number(n) / Number(d);
     }
     console.assert(!(num instanceof Complex) || num.im !== 0);
     return null;
@@ -14157,7 +14198,7 @@ function asBignum(expr) {
         const [n, d] = num;
         if (typeof n === 'number' && typeof d === 'number')
             return expr.engine.bignum(n / d);
-        return n.div(d);
+        return expr.engine.bignum(n).div(d.toString());
     }
     console.assert(!(num instanceof Complex) || num.im !== 0);
     return null;
@@ -14190,7 +14231,7 @@ function asSmallInteger(expr) {
         if (typeof n === 'number' && typeof d === 'number')
             v = n / d;
         else
-            v = n.div(d).toNumber();
+            v = Number(n) / Number(d);
         if (Number.isInteger(v) && v >= -SMALL_INTEGER && v <= SMALL_INTEGER)
             return v;
         return null;
@@ -14209,6 +14250,124 @@ function chop(n, tolerance) {
     return n;
 }
 
+function bigint(a) {
+    if (typeof a === 'bigint')
+        return a;
+    if (a instanceof Decimal)
+        return bigint(a.toString());
+    // BigInt constructor does not deal well with e.g. `1e30` or `1.2e5`
+    let s = a.toString();
+    const m = s.match(/([^\.]+)(?:\.([0-9]+))?e(.+)$/);
+    if (m) {
+        s =
+            m[1] +
+                (m[2] ?? '') +
+                '0'.repeat(parseInt(m[3]) - (m[2] ? m[2].length : 0));
+    }
+    return BigInt(s);
+}
+function gcd(a, b) {
+    while (b !== BigInt(0))
+        [a, b] = [b, a % b];
+    return a < 0 ? -a : a;
+}
+// Difference between primes from 7 to 31
+const PRIME_WHEEL_INC = [
+    BigInt(4),
+    BigInt(2),
+    BigInt(4),
+    BigInt(2),
+    BigInt(4),
+    BigInt(6),
+    BigInt(2),
+    BigInt(6),
+];
+function primeFactors(d) {
+    if (d < Number.MAX_SAFE_INTEGER) {
+        const factors = primeFactors$1(Number(d));
+        const result = new Map();
+        for (const f of Object.keys(factors))
+            result.set(bigint(f), factors[f]);
+        return result;
+    }
+    //https:rosettacode.org/wiki/Prime_decomposition#JavaScript
+    let n = d;
+    const result = new Map();
+    // Wheel factorization
+    // @todo: see https://github.com/Fairglow/prime-factor/blob/main/src/lib.rs
+    let count2 = 0;
+    let count3 = 0;
+    let count5 = 0;
+    let k = BigInt(10);
+    while (n % k === BigInt(0)) {
+        count2 += 1;
+        count5 += 1;
+        n = n / k;
+    }
+    k = BigInt(5);
+    while (n % k === BigInt(0)) {
+        count5 += 1;
+        n = n / k;
+    }
+    k = BigInt(3);
+    while (n % k === BigInt(0)) {
+        count3 += 1;
+        n = n / k;
+    }
+    k = BigInt(2);
+    while (n % k === BigInt(0)) {
+        count2 += 1;
+        n = n / k;
+    }
+    if (count2 > 0)
+        result.set('2', count2);
+    if (count3 > 0)
+        result.set('3', count3);
+    if (count5 > 0)
+        result.set('5', count5);
+    k = BigInt(7);
+    let kIndex = '';
+    let i = 0;
+    while (k * k < n) {
+        if (n % k === BigInt(0)) {
+            if (!kIndex)
+                kIndex = k.toString();
+            result.set(kIndex, (result.get(kIndex) ?? 0) + 1);
+            n = n / k;
+        }
+        else {
+            k = k + PRIME_WHEEL_INC[i];
+            kIndex = '';
+            i = i < 7 ? i + 1 : 0;
+        }
+    }
+    if (n !== BigInt(1))
+        result.set(n.toString(), (result.get(n.toString()) ?? 0) + 1);
+    const r = new Map();
+    for (const [k, v] of result)
+        r.set(bigint(k), v);
+    return r;
+}
+/** Return `[factor, root]` such that
+ * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
+ *
+ * factorPower(75, 2) -> [5, 3] = 5^2 * 3
+ *
+ */
+function factorPower(n, exponent) {
+    // @todo: handle negative n
+    const factors = primeFactors(n);
+    let f = BigInt(1);
+    let r = BigInt(1);
+    const exp = bigint(exponent);
+    for (const [k, v] of factors) {
+        const v2 = bigint(v);
+        f = f * k ** (v2 / exp);
+        r = r * k ** (v2 % exp);
+    }
+    return [f, r];
+}
+
 function isLatexString(s) {
     if (typeof s === 'string')
         return s.startsWith('$') && s.endsWith('$');
@@ -14250,37 +14409,41 @@ function getImaginaryCoef(expr) {
 /**
  * Return the free symbols in the expression, recursively.
  * A variable, or free symbol, is a symbol that is not bound to a value.
+ * Note: do not use `isFree`: it has a side effect of creating a definition
+ * if one does not exist, and we want to avoid that. For example, `assume()`
+ * relies on `expr.freeVars` *not* creating a definition.
  */
-function getVars(expr) {
+function getFreeVars(expr, set) {
     if (expr.symbol) {
-        const def = expr.symbolDefinition;
-        return def?.constant ? [] : [expr.symbol];
+        const def = expr.engine.lookupSymbol(expr.symbol);
+        if (def?.value === undefined)
+            set.add(expr.symbol);
+        return;
     }
     if (!expr.ops && !expr.keys)
-        return [];
-    const result = [];
+        return;
     if (expr.ops)
         for (const op of expr.ops)
-            result.push(...getVars(op));
+            getFreeVars(op, set);
     if (expr.keys)
         for (const key of expr.keys)
-            result.push(...getVars(expr.getKey(key)));
-    return result;
+            getFreeVars(expr.getKey(key), set);
+    return;
 }
 function getSymbols(expr, set) {
     if (expr.symbol) {
         set.add(expr.symbol);
-        return set;
+        return;
     }
     if (!expr.ops && !expr.keys)
-        return set;
+        return;
     if (expr.ops)
         for (const op of expr.ops)
             getSymbols(op, set);
     if (expr.keys)
         for (const key of expr.keys)
             getSymbols(expr.getKey(key), set);
-    return set;
+    return;
 }
 function getSubexpressions(expr, head) {
     const result = !head || expr.head === head ? [expr] : [];
@@ -14313,20 +14476,14 @@ function hashCode(s) {
         hash = (Math.imul(31, hash) + s.charCodeAt(i)) | 0; // | 0 to convert to 32-bit int
     return Math.abs(hash);
 }
-/**
- * If `expr` is a number, return it as a Decimal (it might be
- * in the machine value range or not). Use `isInMachineRange()` to check.
- *
- * Use this instead of `machineValue()` when possible, as `machineValue` will
- * truncate bignums to machine numbers
- */
-function bignumValue(ce, expr) {
+function bigintValue(ce, expr) {
     if (expr === null || expr === undefined)
         return null;
     if (typeof expr === 'number')
-        return ce.bignum(expr);
-    if (isNumberObject(expr)) {
-        let s = expr.num
+        return Number.isInteger(expr) ? bigint(expr) : null;
+    if (isNumberExpression(expr)) {
+        const num = isNumberObject(expr) ? expr.num.toString() : expr;
+        let s = num
             .toLowerCase()
             .replace(/[nd]$/g, '')
             .replace(/[\u0009-\u000d\u0020\u00a0]/g, '');
@@ -14338,14 +14495,26 @@ function bignumValue(ce, expr) {
                     (trail ?? '');
         }
         if (s === 'nan')
-            return ce.bignum('NaN');
+            return null;
         if (s === 'infinity' || s === '+infinity')
-            return ce.bignum('+Infinity');
+            return null;
         if (s === '-infinity')
-            return ce.bignum('-Infinity');
-        return ce.bignum(s);
+            return null;
+        if (s.includes('.'))
+            return null;
+        return bigint(s);
     }
     return null;
+}
+function asBigint(expr) {
+    const num = expr.numericValue;
+    if (num === null)
+        return null;
+    if (typeof num === 'number' && Number.isInteger(num))
+        return bigint(num);
+    if (num instanceof Decimal && num.isInteger())
+        return bigint(num);
+    return null;
 }
 
 /**
@@ -14500,586 +14669,148 @@ function getWildcardName(s) {
 // @todo: ['Repeated',...] : repeating match
 // @todo _x:Head or _x:RealNumber
 
+function isRational(x) {
+    return x !== null && Array.isArray(x);
+}
+function isMachineRational(x) {
+    return x !== null && Array.isArray(x) && typeof x[0] === 'number';
+}
+function isBigRational(x) {
+    return x !== null && Array.isArray(x) && typeof x[0] === 'bigint';
+}
+function isRationalZero(x) {
+    // Note '==' to convert bigint to number
+    return x[0] == 0;
+}
+function isRationalOne(x) {
+    return x[0] === x[1];
+}
+function isRationalNegativeOne(x) {
+    return x[0] === -x[1];
+}
+function machineNumerator(x) {
+    return Number(x[0]);
+}
+function machineDenominator(x) {
+    return Number(x[1]);
+}
+function isNeg(x) {
+    return x[0] < 0;
+}
+function neg(x) {
+    return [-x[0], x[1]];
+}
+function inverse(x) {
+    return x[0] < 0 ? [-x[1], -x[0]] : [x[1], x[0]];
+}
+function asRational(expr) {
+    const num = expr.numericValue;
+    if (num === null)
+        return undefined;
+    if (Array.isArray(num))
+        return num;
+    if (typeof num === 'number' && Number.isInteger(num))
+        return [num, 1];
+    if (num instanceof Decimal && num.isInteger())
+        return [bigint(num), BigInt(1)];
+    return undefined;
+}
+function asMachineRational(r) {
+    return [Number(r[0]), Number(r[1])];
+}
 /**
- * Flatten the arguments.
- * If `expr` was canonical, the result it canonical.
+ * Add a literal numeric value to a rational.
+ * If the rational is a bignum, this is a hint to do the calculation in bignum
+ * (no need to check `bignumPreferred()`).
+ * @param lhs
+ * @param rhs
+ * @returns
  */
-function flattenOps(ops, head) {
-    const result = [];
-    for (const arg of ops) {
-        if (!arg.ops || arg.head !== head)
-            result.push(arg);
-        else {
-            // ["f", a, ["f", b, c]] -> ["f", a, b, c]
-            // or ["f", ["f", a]] -> ["f", a]
-            result.push(...(flattenOps(arg.ops, head) ?? arg.ops));
+function add(lhs, rhs) {
+    console.assert(Array.isArray(rhs) ||
+        (rhs.numericValue !== null && !(rhs instanceof Complex)));
+    if (Array.isArray(rhs)) {
+        if (isBigRational(rhs)) {
+            lhs = [bigint(lhs[0]), bigint(lhs[1])];
+            return [rhs[1] * lhs[0] + rhs[0] * lhs[1], rhs[1] * lhs[1]];
         }
-    }
-    // If number of arguments didn't change, we didn't flatten
-    if (result.length === ops.length)
-        return null;
-    return result;
-}
-function flattenSequence(xs) {
-    const ys = [];
-    for (const x of xs) {
-        if (x.head === 'Sequence') {
-            if (x.ops)
-                ys.push(...x.ops);
+        if (isBigRational(lhs)) {
+            rhs = [bigint(rhs[0]), bigint(rhs[1])];
+            return [rhs[1] * lhs[0] + rhs[0] * lhs[1], rhs[1] * lhs[1]];
         }
-        else
-            ys.push(x);
+        return [rhs[1] * lhs[0] + rhs[0] * lhs[1], rhs[1] * lhs[1]];
     }
-    return ys;
-}
-
-function validateArgumentCount(ce, ops, count) {
-    if (ops.length === count)
-        return ops;
-    const xs = [...ops.slice(0, count)];
-    let i = Math.min(count, ops.length);
-    while (i < count) {
-        xs.push(ce.error('missing'));
-        i += 1;
+    let rhsNum = rhs.numericValue;
+    console.assert(rhs.isInteger);
+    if (rhsNum !== null && typeof rhsNum === 'number') {
+        if (isMachineRational(lhs))
+            return [lhs[0] + lhs[1] * rhsNum, lhs[1]];
+        return [lhs[0] + lhs[1] * bigint(rhsNum), lhs[1]];
     }
-    while (i < ops.length) {
-        xs.push(ce.error('unexpected-argument', ops[i]));
-        i += 1;
+    if (rhsNum instanceof Decimal) {
+        if (isMachineRational(lhs))
+            lhs = [bigint(lhs[0]), bigint(lhs[1])];
+        return [lhs[0] + lhs[1] * bigint(rhsNum.toString()), lhs[1]];
     }
-    return xs;
-}
-/**
- * Validation of arguments is normally done by checking the signature of the
- * function vs the arguments of the expression. However, we have a fastpath
- * for some common operations (add, multiply, power, neg, etc...) that bypasses
- * the regular checks. This is its replacements. Since all those fastpath
- * functions are numeric (i.e. have numeric arguments and return a numeric
- * value), we do a simple numeric check of all arguments, and verify we have
- * the number of expected arguments.
- */
-function validateNumericArgs(ce, ops, count) {
-    // @fastpath
-    if (!ce.strict)
-        return ops.map((x) => ce.box(x));
-    let xs = [];
-    if (count === undefined) {
-        xs = ops.map((x) => ce.box(x));
+    if (Array.isArray(rhsNum)) {
+        if (isMachineRational(rhsNum))
+            rhsNum = [bigint(rhsNum[0]), bigint(rhsNum[1])];
+        if (isMachineRational(lhs))
+            lhs = [bigint(lhs[0]), bigint(lhs[1])];
+        return [rhsNum[1] * lhs[0] + rhsNum[0] * lhs[1], rhsNum[1] * lhs[1]];
     }
-    else
-        for (let i = 0; i <= Math.max(count - 1, ops.length - 1); i++) {
-            if (i > count - 1)
-                xs.push(ce.error('unexpected-argument', ops[i]));
-            else
-                xs.push(ops[i] !== undefined
-                    ? ce.box(ops[i])
-                    : ce.error(['missing', 'Number']));
-        }
-    return flattenSequence(xs).map((op) => !op.isValid || op.isNumber
-        ? op
-        : ce.error(['incompatible-domain', 'Number', op.domain], op));
-}
-/** Return `null` if the `ops` match the sig. Otherwise, return an array
- * of expressions indicating the mismatched arguments.
- *
- */
-function validateSignature(sig, ops, codomain) {
-    const ce = sig.engine;
-    // @fastpath
-    if (!ce.strict)
-        return ops;
-    const opsDomain = ops.map((x) => x.domain);
-    const targetSig = ce.domain([
-        'Function',
-        ...opsDomain,
-        codomain ?? 'Anything',
-    ]);
-    if (sig.isCompatible(targetSig))
-        return null;
-    //
-    // There was a problem:
-    // 1/ not enough arguments
-    // 2/ too many arguments
-    // 3/ incompatible argument domain
-    //
-    // Iterate over each arg, and replace with error expression when appropriate
-    //
-    const expectedArgs = sig.domainArgs.slice(0, -1);
-    const count = Math.max(expectedArgs.length, opsDomain.length);
-    let newOps = [];
-    let rest = [...ops];
-    for (let i = 0; i <= count - 1; i++)
-        [newOps, rest] = validateNextArgument(ce, expectedArgs[i], newOps, rest);
-    // Remove any 'Nothing' at the end
-    while (newOps.length > 0 && newOps[newOps.length - 1].symbol === 'Nothing')
-        newOps.pop();
-    return newOps;
-}
-function validateArgument(ce, arg, expect) {
-    if (expect === undefined)
-        return ce.error('unexpected-argument', arg);
-    if (arg === undefined)
-        return ce.error(['missing', expect]);
-    if (!arg.isValid)
-        return arg;
-    if (arg?.domain.isCompatible(ce.domain(expect)))
-        return arg;
-    return ce.error(['incompatible-domain', expect, arg.domain], arg);
-}
-function validateNextArgument(ce, expect, matched, ops) {
-    let next = ops.shift();
-    if (expect === undefined)
-        return [[...matched, ce.error('unexpected-argument', next)], ops];
-    if (!Array.isArray(expect)) {
-        if (!next)
-            return [[...matched, ce.error(['missing', expect])], ops];
-        if (!next.domain.isCompatible(ce.domain(expect))) {
-            return [
-                [
-                    ...matched,
-                    ce.error(['incompatible-domain', expect, next.domain], next),
-                ],
-                ops,
-            ];
-        }
-        return [[...matched, next], ops];
-    }
-    const ctor = expect[0];
-    if (next === undefined) {
-        //
-        // An expected argument is missing. Is that OK?
-        //
-        let valid = false;
-        if (ctor === 'Union') {
-            //  If an `Union`, was `Nothing` an option?
-            for (let k = 1; k <= expect.length - 1; k++) {
-                if (expect[k] === 'Nothing') {
-                    valid = true;
-                    break;
-                }
-            }
-        }
-        else if (ctor === 'Maybe')
-            valid = true;
-        if (valid)
-            return [[...matched, ce.symbol('Nothing')], ops];
-        return [[...matched, ce.error(['missing', expect])], ops];
-    }
-    if (ctor === 'Union') {
-        //
-        // We expect one of several domains. Check if at least one matches
-        //
-        let found = false;
-        for (let k = 1; k <= expect.length - 1; k++) {
-            if (next.domain.isCompatible(ce.domain(expect[k]))) {
-                found = true;
-                break;
-            }
-        }
-        if (found)
-            return [[...matched, next], ops];
-        return [
-            [
-                ...matched,
-                ce.error(['incompatible-domain', expect, next.domain], next),
-            ],
-            ops,
-        ];
-    }
-    if (ctor === 'Sequence') {
-        const seq = ce.domain(expect[1]);
-        if (!next || !next.domain.isCompatible(seq)) {
-            return [
-                [...matched, ce.error(['incompatible-domain', seq, next.domain], next)],
-                ops,
-            ];
-        }
-        let done = false;
-        const result = [...matched, next];
-        while (!done) {
-            next = ops.shift();
-            if (!next)
-                done = false;
-            else if (!next.domain.isCompatible(seq)) {
-                ops.unshift(next);
-                done = false;
-            }
-            else
-                result.push(next);
-        }
-        return [result, ops];
-    }
-    if (ctor === 'Maybe') {
-        if (next === undefined || next.symbol === 'Nothing')
-            return [[...matched, ce.symbol('Nothing')], ops];
-        return validateNextArgument(ce, expect[1], matched, [next, ...ops]);
-    }
-    console.error('Unhandled ctor', ctor);
-    return [[...matched, next], ops];
-}
-
-function gcd(a, b) {
-    //@todo: https://github.com/Yaffle/bigint-gcd/blob/main/gcd.js
-    console.assert(a.isInteger() && b.isInteger());
-    while (!b.isZero())
-        [a, b] = [b, a.modulo(b)];
-    return a.abs();
-}
-// Difference between primes from 7 to 31
-const PRIME_WHEEL_INC = [4, 2, 4, 2, 4, 6, 2, 6];
-function primeFactors(ce, n) {
-    if (n.lt(Number.MAX_SAFE_INTEGER)) {
-        const factors = primeFactors$1(n.toNumber());
-        const result = new Map();
-        for (const f of Object.keys(factors))
-            result.set(ce.bignum(f), factors[f]);
-        return result;
-    }
-    //https:rosettacode.org/wiki/Prime_decomposition#JavaScript
-    const result = new Map();
-    // Wheel factorization
-    // @todo: see https://github.com/Fairglow/prime-factor/blob/main/src/lib.rs
-    // @todo: rewrite using Bignum
-    let count = 0;
-    while (n.mod(2).isZero()) {
-        count += 1;
-        n = n.div(2);
-    }
-    if (count > 0)
-        result.set('2', count);
-    count = 0;
-    while (n.mod(3).isZero()) {
-        count += 1;
-        n = n.div(3);
-    }
-    if (count > 0)
-        result.set('3', count);
-    while (n.mod(5).isZero()) {
-        count += 1;
-        n = n.div(5);
-    }
-    if (count > 0)
-        result.set('5', count);
-    let k = ce.bignum(7);
-    let kIndex = k.toString();
-    let i = 0;
-    while (k.mul(k).lt(n)) {
-        if (n.mod(k).isZero()) {
-            result.set(kIndex, (result.get(kIndex) ?? 0) + 1);
-            n = n.div(k);
-        }
-        else {
-            k = k.add(PRIME_WHEEL_INC[i]);
-            kIndex = k.toString();
-            i = i < 7 ? i + 1 : 0;
-        }
-    }
-    if (!n.eq(1))
-        result.set(n.toString(), 1);
-    const r = new Map();
-    for (const [k, v] of result)
-        r.set(ce.bignum(k), v);
-    return r;
-}
-/** Return `[factor, root]` such that
- * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
- *
- * factorPower(75, 2) -> [5, 3] = 5^2 * 3
- *
- */
-function factorPower(ce, n, exponent) {
-    // @todo: handle negative n
-    console.assert(n.isInteger() && n.isPositive());
-    const factors = primeFactors(ce, n);
-    let f = ce.bignum(1);
-    let r = ce.bignum(1);
-    for (const [k, v] of factors) {
-        const v2 = ce.bignum(v);
-        f = f.mul(k.pow(v2.div(exponent).floor()));
-        r = r.mul(k.pow(v2.mod(exponent)));
-    }
-    return [f, r];
-}
-function factorial(ce, n) {
-    if (!n.isInteger() || n.isNegative())
-        return ce._BIGNUM_NAN;
-    if (n.lessThan(10))
-        return ce.bignum([1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800][n.toNumber()]);
-    if (n.gt(Number.MAX_SAFE_INTEGER)) {
-        let val = ce._BIGNUM_ONE;
-        let i = ce._BIGNUM_TWO;
-        while (i.lessThan(n)) {
-            val = val.mul(i);
-            i = i.add(1);
-        }
-        return val;
-    }
-    if (n.modulo(2).eq(1)) {
-        return n.times(factorial(ce, n.minus(1)));
-    }
-    let loop = n.toNumber();
-    let sum = n;
-    let val = n;
-    while (loop > 2) {
-        loop -= 2;
-        sum = sum.add(loop);
-        val = val.mul(sum);
-    }
-    return val;
-}
-const gammaG = 7;
-// Spouge approximation (suitable for large arguments)
-function lngamma$1(ce, z) {
-    if (z.isNegative())
-        return ce._BIGNUM_NAN;
-    const GAMMA_P_LN = ce.cache('gamma-p-ln', () => {
-        return [
-            '0.99999999999999709182',
-            '57.156235665862923517',
-            '-59.597960355475491248',
-            '14.136097974741747174',
-            '-0.49191381609762019978',
-            '0.33994649984811888699e-4',
-            '0.46523628927048575665e-4',
-            '-0.98374475304879564677e-4',
-            '0.15808870322491248884e-3',
-            '-0.21026444172410488319e-3',
-            '0.2174396181152126432e-3',
-            '-0.16431810653676389022e-3',
-            '0.84418223983852743293e-4',
-            '-0.2619083840158140867e-4',
-            '0.36899182659531622704e-5',
-        ].map((x) => ce.bignum(x));
-    });
-    let x = GAMMA_P_LN[0];
-    for (let i = GAMMA_P_LN.length - 1; i > 0; --i) {
-        x = x.add(GAMMA_P_LN[i].div(z.add(i)));
-    }
-    const GAMMA_G_LN = ce.cache('gamma-g-ln', () => ce.bignum(607).div(128));
-    const t = z.add(GAMMA_G_LN).add(ce._BIGNUM_HALF);
-    return ce._BIGNUM_NEGATIVE_ONE
-        .acos()
-        .mul(ce._BIGNUM_TWO)
-        .log()
-        .mul(ce._BIGNUM_HALF)
-        .add(t.log().mul(z.add(ce._BIGNUM_HALF)).minus(t).add(x.log()).minus(z.log()));
-}
-// From https://github.com/substack/gamma.js/blob/master/index.js
-function gamma$1(ce, z) {
-    if (z.lessThan(ce._BIGNUM_HALF)) {
-        const pi = ce._BIGNUM_NEGATIVE_ONE.acos();
-        return pi.div(pi
-            .mul(z)
-            .sin()
-            .mul(gamma$1(ce, ce._BIGNUM_ONE.sub(z))));
-    }
-    if (z.greaterThan(100))
-        return lngamma$1(ce, z).exp();
-    z = z.sub(1);
-    // coefficients for gamma=7, kmax=8  Lanczos method
-    // Source: GSL/specfunc/gamma.c
-    const LANCZOS_7_C = ce.cache('lanczos-7-c', () => {
-        return [
-            '0.99999999999980993227684700473478',
-            '676.520368121885098567009190444019',
-            '-1259.13921672240287047156078755283',
-            '771.3234287776530788486528258894',
-            '-176.61502916214059906584551354',
-            '12.507343278686904814458936853',
-            '-0.13857109526572011689554707',
-            '9.984369578019570859563e-6',
-            '1.50563273514931155834e-7',
-        ].map((x) => ce.bignum(x));
-    });
-    let x = LANCZOS_7_C[0];
-    for (let i = 1; i < gammaG + 2; i++)
-        x = x.add(LANCZOS_7_C[i].div(z.add(i)));
-    const t = z.add(gammaG).add(ce._BIGNUM_HALF);
-    return ce._BIGNUM_NEGATIVE_ONE
-        .acos()
-        .times(ce._BIGNUM_TWO)
-        .sqrt()
-        .mul(x.mul(t.neg().exp()).mul(t.pow(z.add(ce._BIGNUM_HALF))));
-}
-/**
- * If the exponent of the bignum is in the range of the exponents
- * for machine numbers,return true.
- */
-function isInMachineRange(d) {
-    if (!d.isFinite())
-        return true; // Infinity and NaN are in machine range
-    // Are there too many significant digits?
-    // Maximum Safe Integer is 9007199254740991
-    // Digits in Decimal are stored by blocks of 7.
-    // Three blocks, with the first block = 90 is close to the maximum
-    if (d.d.length > 3 || (d.d.length === 3 && d.d[0] >= 90))
-        return false;
-    console.assert(d.precision() <= 16);
-    // Is the exponent within range?
-    // With a binary 64 IEEE 754 number:
-    // significant bits: 53 -> 15 digits
-    // exponent bits: 11. emax = 307, emin = -306)
-    return d.e < 308 && d.e > -306;
-}
-// export function asMachineNumber(d: Decimal): number | null {
-//   if (d.precision() < 15 && d.e < 308 && d.e > -306) return d.toNumber();
-//   return null;
-// }
-
-function isRational(x) {
-    return x !== null && Array.isArray(x);
-}
-function isMachineRational(x) {
-    return x !== null && Array.isArray(x) && typeof x[0] === 'number';
-}
-function isBigRational(x) {
-    return x !== null && Array.isArray(x) && x[0] instanceof Decimal;
-}
-function isRationalZero(x) {
-    if (x[0] === 0)
-        return true;
-    return x[0] instanceof Decimal && x[0].isZero();
-}
-function isRationalOne(x) {
-    if (x[0] === x[1])
-        return true;
-    if (typeof x[0] === 'number')
-        return false;
-    return x[0].eq(x[1]);
-}
-function isRationalNegativeOne(x) {
-    if (typeof x[0] === 'number')
-        return x[0] === -x[1];
-    return x[0].eq(x[1].neg());
-}
-function machineNumerator(x) {
-    return typeof x[0] === 'number' ? x[0] : x[0].toNumber();
-}
-function machineDenominator(x) {
-    return typeof x[1] === 'number' ? x[1] : x[1].toNumber();
-}
-function isNeg(lhs) {
-    if (isMachineRational(lhs))
-        return lhs[0] < 0;
-    return lhs[0].isNeg();
-}
-function neg(lhs) {
-    if (isMachineRational(lhs))
-        return [-lhs[0], lhs[1]];
-    return [lhs[0].neg(), lhs[1]];
-}
-function inverse(lhs) {
-    if (isMachineRational(lhs))
-        return lhs[0] < 0 ? [-lhs[1], -lhs[0]] : [lhs[1], lhs[0]];
-    return lhs[0].isNeg() ? [lhs[1].neg(), lhs[0].neg()] : [lhs[1], lhs[0]];
-}
-function asRational(expr) {
-    const num = expr.numericValue;
-    if (num === null)
-        return undefined;
-    if (Array.isArray(num))
-        return num;
-    if (typeof num === 'number' && Number.isInteger(num))
-        return [num, 1];
-    if (num instanceof Decimal && num.isInteger())
-        return [num, expr.engine._BIGNUM_ONE];
-    return undefined;
-}
-function asMachineRational(r) {
-    if (isMachineRational(r))
-        return r;
-    return [r[0].toNumber(), r[1].toNumber()];
-}
-/**
- * Add a literal numeric value to a rational.
- * If the rational is a bignum, this is a hint to do the calculation in bignum
- * (no need to check `bignumPreferred()`).
- * @param lhs
- * @param rhs
- * @returns
- */
-function add(lhs, rhs) {
-    console.assert(Array.isArray(rhs) ||
-        (rhs.numericValue !== null && !(rhs instanceof Complex)));
-    if (Array.isArray(rhs)) {
-        if (isBigRational(rhs))
-            return [rhs[1].mul(lhs[0]).add(rhs[0].mul(lhs[1])), rhs[1].mul(lhs[1])];
-        if (isBigRational(lhs))
-            return [lhs[0].mul(rhs[1]).add(lhs[1].mul(rhs[0])), lhs[1].mul(rhs[1])];
-        return [rhs[1] * lhs[0] + rhs[0] * lhs[1], rhs[1] * lhs[1]];
-    }
-    const rhsNum = rhs.numericValue;
-    if (rhsNum !== null && typeof rhsNum === 'number') {
-        if (isMachineRational(lhs))
-            return [lhs[0] + lhs[1] * rhsNum, lhs[1]];
-        return [lhs[0].add(lhs[1].mul(rhsNum)), lhs[1]];
-    }
-    if (rhsNum instanceof Decimal) {
-        if (isMachineRational(lhs)) {
-            const ce = rhs.engine;
-            return [ce.bignum(rhsNum.mul(lhs[1]).add(lhs[0])), ce.bignum(lhs[1])];
-        }
-        return [lhs[0].add(lhs[1].mul(rhsNum)), lhs[1]];
-    }
-    if (Array.isArray(rhsNum)) {
-        if (isBigRational(rhsNum))
-            return [
-                rhsNum[1].mul(lhs[0]).add(rhsNum[0].mul(lhs[1])),
-                rhsNum[1].mul(lhs[1]),
-            ];
-        if (isBigRational(lhs))
-            return [
-                lhs[0].mul(rhsNum[1]).add(lhs[1].mul(rhsNum[0])),
-                lhs[1].mul(rhsNum[1]),
-            ];
-        return [rhsNum[1] * lhs[0] + rhsNum[0] * lhs[1], rhsNum[1] * lhs[1]];
-    }
-    debugger;
-    return lhs;
+    debugger;
+    return lhs;
 }
 function mul(lhs, rhs) {
     console.assert(Array.isArray(rhs) ||
         (rhs.numericValue !== null && !(rhs instanceof Complex)));
     if (Array.isArray(rhs)) {
-        if (isBigRational(lhs))
-            return [lhs[0].mul(rhs[0]), lhs[1].mul(rhs[1])];
-        if (isBigRational(rhs))
-            return [rhs[0].mul(lhs[0]), rhs[1].mul(lhs[1])];
-        return [rhs[0] * lhs[0], rhs[1] * lhs[1]];
+        if (isMachineRational(lhs) && isMachineRational(rhs))
+            return [lhs[0] * rhs[0], lhs[1] * rhs[1]];
+        if (isMachineRational(lhs))
+            lhs = [bigint(lhs[0]), bigint(lhs[1])];
+        if (isMachineRational(rhs))
+            rhs = [bigint(rhs[0]), bigint(rhs[1])];
+        return [lhs[0] * rhs[0], lhs[1] * rhs[1]];
     }
     const rhsNum = rhs.numericValue;
     if (rhsNum !== null && typeof rhsNum === 'number') {
+        console.assert(Number.isInteger(rhsNum));
         if (isMachineRational(lhs))
             return [lhs[0] * rhsNum, lhs[1]];
-        return [lhs[0].mul(rhsNum), lhs[1]];
+        return [lhs[0] * bigint(rhsNum), lhs[1]];
     }
     if (rhsNum instanceof Decimal) {
+        console.assert(rhsNum.isInteger());
         if (isMachineRational(lhs))
-            return [rhsNum.mul(lhs[0]), rhs.engine.bignum(lhs[1])];
-        return [rhsNum.mul(lhs[0]), lhs[1]];
+            return [bigint(rhsNum.toString()) * bigint(lhs[0]), bigint(lhs[1])];
+        return [bigint(rhsNum.toString()) * lhs[0], lhs[1]];
     }
     if (Array.isArray(rhsNum)) {
         if (isBigRational(rhsNum))
-            return [rhsNum[0].mul(lhs[0]), rhsNum[1].mul(lhs[1])];
+            return [rhsNum[0] * bigint(lhs[0]), rhsNum[1] * bigint(lhs[1])];
         else if (isMachineRational(lhs))
             return [lhs[0] * rhsNum[0], lhs[1] * rhsNum[1]];
-        return [lhs[0].mul(rhsNum[0]), lhs[1].mul(rhsNum[1])];
+        return [lhs[0] * bigint(rhsNum[0]), lhs[1] * bigint(rhsNum[1])];
     }
     debugger;
     return lhs;
 }
 function pow(r, exp) {
     console.assert(Number.isInteger(exp));
+    if (exp === 0)
+        return [1, 1];
     if (exp < 0) {
         r = inverse(r);
         exp = -exp;
     }
-    if (exp === 0)
-        return [1, 1];
     if (exp === 1)
         return r;
     if (isMachineRational(r))
         return [Math.pow(r[0], exp), Math.pow(r[1], exp)];
-    return [r[0].pow(exp), r[1].pow(exp)];
+    const bigexp = bigint(exp);
+    return [r[0] ** bigexp, r[1] ** bigexp];
 }
 function reducedRational(r) {
     if (isMachineRational(r)) {
@@ -15087,19 +14818,21 @@ function reducedRational(r) {
             return r;
         if (r[1] < 0)
             r = [-r[0], -r[1]];
+        if (!Number.isFinite(r[1]))
+            return [0, 1];
         const g = gcd$1(r[0], r[1]);
         //  If the gcd is 0, return the rational unchanged
         return g <= 1 ? r : [r[0] / g, r[1] / g];
     }
-    if (r[0].equals(1) || r[1].equals(1))
+    if (r[0] === BigInt(1) || r[1] === BigInt(1))
         return r;
-    if (r[1].isNegative())
-        r = [r[0].neg(), r[1].neg()];
+    if (r[1] < 0)
+        r = [-r[0], -r[1]];
     const g = gcd(r[0], r[1]);
     //  If the gcd is 0, return the rational unchanged
-    if (g.lessThanOrEqualTo(1))
+    if (g <= 1)
         return r;
-    return [r[0].div(g), r[1].div(g)];
+    return [r[0] / g, r[1] / g];
 }
 /** Return a rational approximation of x */
 function rationalize(x) {
@@ -15168,12 +14901,14 @@ function asCoefficient(expr) {
         const rest = [];
         let coef = [1, 1];
         for (const arg of expr.ops) {
-            // Only consider the value of literals
             const n = arg.numericValue;
-            if (n === null || n instanceof Complex)
-                rest.push(arg);
-            else
+            if (n !== null &&
+                ((typeof n === 'number' && Number.isInteger(n)) ||
+                    (n instanceof Decimal && n.isInteger()) ||
+                    isRational(n)))
                 coef = mul(coef, arg);
+            else
+                rest.push(arg);
         }
         coef = reducedRational(coef);
         if (isRationalOne(coef))
@@ -15192,11 +14927,9 @@ function asCoefficient(expr) {
         let [coef1, numer] = asCoefficient(expr.op1);
         const [coef2, denom] = asCoefficient(expr.op2);
         const coef = reducedRational(mul(coef1, inverse(coef2)));
-        if (numer.isOne && denom.isOne)
-            return [coef, ce._ONE];
         if (denom.isOne)
             return [coef, numer];
-        return [coef, ce.fn('Divide', [numer, denom])];
+        return [coef, ce.div(numer, denom)];
     }
     //
     // Power
@@ -15212,9 +14945,9 @@ function asCoefficient(expr) {
         const exponent = expr.op2;
         const e = asSmallInteger(exponent);
         if (e === -1)
-            return [inverse(coef), ce.inverse(base)];
+            return [inverse(coef), ce.inv(base)];
         if (e !== null)
-            return [pow(coef, e), ce.power(base, exponent)];
+            return [pow(coef, e), ce.pow(base, exponent)];
         // The exponent might be a rational (square root, cubic root...)
         if (exponent.numericValue !== null &&
             Array.isArray(exponent.numericValue)) {
@@ -15228,13 +14961,17 @@ function asCoefficient(expr) {
                 // en = -1 -> inverse the extracted coef
                 return [
                     en === 1 ? [nCoef, dCoef] : [dCoef, nCoef],
-                    ce.power(ce.mul([ce.number([nRest, dRest]), base]), exponent),
+                    ce.pow(ce.mul([ce.number([nRest, dRest]), base]), exponent),
                 ];
             }
         }
         return [[1, 1], expr];
     }
     //
+    // Add
+    //
+    if (expr.head === 'Add') ;
+    //
     // Negate
     //
     if (expr.head === 'Negate') {
@@ -15248,8 +14985,8 @@ function asCoefficient(expr) {
     const n = expr.numericValue;
     if (n !== null) {
         if (n instanceof Decimal) {
-            if (n.isInteger() && isInMachineRange(n))
-                return [[n.toNumber(), 1], ce._ONE];
+            if (n.isInteger())
+                return [[bigint(n.toString()), BigInt(1)], ce._ONE];
             if (n.isNegative())
                 return [[-1, 1], ce.number(n.neg())];
         }
@@ -15259,7 +14996,7 @@ function asCoefficient(expr) {
             if (n < 0)
                 return [[-1, 1], ce.number(-n)];
         }
-        if (Array.isArray(n))
+        if (isRational(n))
             return [n, ce._ONE];
         // Make the part positive if the real part is negative
         if (n instanceof Complex && n.re < 0)
@@ -15281,7 +15018,7 @@ function signDiff(lhs, rhs, tolerance) {
     const lhsNum = lhsN.numericValue;
     const rhsNum = rhsN.numericValue;
     if (lhsNum === null || rhsNum === null) {
-        // Couldn't calculate a numeric value, use the `sgn`
+        // Couldn't calculate numeric value, use the `sgn` property
         const lhsS = lhs.sgn;
         const rhsS = rhs.sgn;
         if (typeof lhsS !== 'number' || typeof rhsS !== 'number')
@@ -15304,20 +15041,68 @@ function signDiff(lhs, rhs, tolerance) {
         return undefined;
     // In general, it is impossible to always prove equality
     // (Richardson's theorem) but this works often...
-    const rhsR = asRational(rhsN);
-    if (!rhsR)
+    // At this point, lhsNum and rhsNum are either number or Decimal
+    // (it can't be a rational, because lhs.N() simplifies rationals to number or Decimal)
+    if (isRational(lhsNum) || isRational(rhsNum))
         return undefined;
-    const diff = add(neg(rhsR), lhsN);
-    const delta = isMachineRational(diff)
-        ? chop(diff[0] / diff[1], tolerance)
-        : chop(diff[0].div(diff[1]), tolerance);
-    if (delta === 0)
+    if (typeof lhsNum === 'number' && typeof rhsNum === 'number') {
+        if (chop(rhsNum - lhsNum, tolerance) === 0)
+            return 0;
+        return lhsNum < rhsNum ? -1 : 1;
+    }
+    const ce = lhs.engine;
+    const delta = ce.bignum(rhsNum).sub(ce.bignum(lhsNum));
+    if (chop(delta, tolerance) === 0)
         return 0;
-    if (typeof delta === 'number')
-        return delta > 0 ? 1 : -1;
     return delta.isPos() ? 1 : -1;
 }
 
+/**
+ * Flatten the arguments.
+ * If `expr` was canonical, the result it canonical.
+ */
+function flattenOps(ops, head) {
+    if (!head)
+        return ops;
+    // Bypass memory allocation for the common case where there is nothing to flatten
+    if (ops.every((x) => !x.ops || x.head !== head))
+        return ops;
+    const result = [];
+    for (const arg of ops) {
+        if (!arg.ops || arg.head !== head)
+            result.push(arg);
+        else {
+            // ["f", a, ["f", b, c]] -> ["f", a, b, c]
+            // or ["f", ["f", a]] -> ["f", a]
+            result.push(...flattenOps(arg.ops, head));
+        }
+    }
+    // If number of arguments didn't change, we didn't flatten
+    console.assert(result.length !== ops.length); // @todo check below may not be necessary
+    if (result.length === ops.length)
+        return ops;
+    return result;
+}
+function flattenSequence(xs) {
+    // Bypass memory allocation for the common case where there are no sequences
+    if (xs.every((x) => x.head !== 'Sequence'))
+        return xs;
+    const ys = [];
+    for (const x of xs) {
+        if (x.isValid && x.head === 'Sequence') {
+            if (x.ops)
+                ys.push(...x.ops);
+        }
+        else
+            ys.push(x);
+    }
+    return ys;
+}
+function canonical(xs) {
+    // Avoid memory allocation if possible
+    return xs.every((x) => x.isCanonical) ? xs : xs.map((x) => x.canonical);
+}
+
 function negateLiteral(expr, metadata) {
     // Applying negation is safe (doesn't introduce numeric errors)
     // even on floating point numbers
@@ -15336,65 +15121,36 @@ function negateLiteral(expr, metadata) {
 }
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
- * addition or another `Negate`.
- *
- * This is appropriate to call during a `canonical` chain.
+ * addition or multiplication or another `Negate`.
  *
- * For more thorough distribution (including multiplication), see `distributeNegate`,
- * applicable  during a `simplify` or `evaluate` chain.
+ * It is important to do all these to handle cases like
+ * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
 function canonicalNegate(expr, metadata) {
     // Negate(Negate(x)) -> x
-    if (expr.head === 'Negate')
-        return validateArgument(expr.engine, expr.op1?.canonical, 'Number');
-    expr = validateArgument(expr.engine, expr.canonical, 'Number');
-    if (expr.numericValue !== null)
-        return negateLiteral(expr, metadata);
-    // Distribute over addition
-    // Negate(Add(a, b)) -> Add(Negate(a), Negate(b))
-    if (expr.head === 'Add') {
-        let ops = expr.ops.map((x) => canonicalNegate(x));
-        ops = flattenOps(ops, 'Add') ?? ops;
-        return expr.engine.add(ops, metadata);
-    }
-    // 'Subtract' is canonicalized into `Add`, so don't have to worry about it
-    console.assert(expr.head !== 'Subtract');
-    return expr.engine._fn('Negate', [expr], metadata);
-}
-/**
- * Return the additive opposite of the expression.
- *
- * Applies to `Add`, `Multiply`, `Negate` and number literals.
- *
- * If none can be produced (the expression is a symbol for example),
- * return `null`.
- *
- * Call during a `simplify` or `evaluate` chain. Use `caonnicalNegate`  during a
- * `canonical` chain.
- */
-function distributeNegate(expr) {
-    if (expr.numericValue !== null)
-        return negateLiteral(expr);
     if (expr.head === 'Negate')
         return expr.op1;
-    const ce = expr.engine;
+    if (expr.numericValue !== null)
+        return negateLiteral(expr, metadata);
     // Distribute over addition
     // Negate(Add(a, b)) -> Add(Negate(a), Negate(b))
     if (expr.head === 'Add') {
-        let ops = expr.ops.map((x) => distributeNegate(x));
-        ops = flattenOps(ops, 'Add') ?? ops;
-        return ce.add(ops);
+        let ops = expr.ops.map((x) => canonicalNegate(x));
+        ops = flattenOps(ops, 'Add');
+        return expr.engine.add(ops, metadata);
     }
     // Distribute over multiplication
     // Negate(Multiply(a, b)) -> Multiply(Negate(a), b)
     if (expr.head === 'Multiply') {
-        return negateProduct(ce, expr.ops);
+        return negateProduct(expr.engine, expr.ops);
     }
     // Distribute over division
     // Negate(Divide(a, b)) -> Divide(Negate(a), b)
     if (expr.head === 'Divide')
-        return ce.divide(distributeNegate(expr.op1), expr.op2);
-    return ce._fn('Negate', [expr]);
+        return expr.engine._fn('Divide', [canonicalNegate(expr.op1), expr.op2]);
+    // 'Subtract' is canonicalized into `Add`, so don't have to worry about it
+    console.assert(expr.head !== 'Subtract');
+    return expr.engine._fn('Negate', [expr], metadata);
 }
 // Given a list of terms in a product, find the "best" one to negate in
 // order to negate the entire product:
@@ -15422,7 +15178,7 @@ function negateProduct(ce, args) {
             result.push(arg);
         else {
             done = true;
-            result.push(distributeNegate(arg));
+            result.push(canonicalNegate(arg));
         }
     }
     if (done)
@@ -15434,7 +15190,7 @@ function negateProduct(ce, args) {
             result.push(arg);
         else {
             done = true;
-            result.push(distributeNegate(arg));
+            result.push(canonicalNegate(arg));
         }
     }
     if (done)
@@ -15442,7 +15198,7 @@ function negateProduct(ce, args) {
     return ce._fn('Negate', [ce._fn('Multiply', args)]);
 }
 function processNegate(_ce, x, _mode = 'simplify') {
-    return distributeNegate(x);
+    return canonicalNegate(x);
 }
 
 /**
@@ -15499,7 +15255,7 @@ function expand(expr) {
             .add([expand(expr.op1), expand2(ce._NEGATIVE_ONE, expr.op1)])
             .simplify();
     if (expr.head === 'Divide')
-        return ce.divide(expand(expr.op1), expand(expr.op2)).simplify();
+        return ce.div(expand(expr.op1), expand(expr.op2)).simplify();
     if (expr.head === 'Multiply') {
         if (expr.nops === 2)
             return expand2(expr.op1, expr.op2);
@@ -15508,13 +15264,13 @@ function expand(expr) {
     if (expr.head === 'Power') {
         const op1head = expr.op1.head;
         if (op1head === 'Multiply')
-            return ce.mul(expr.op1.ops.map((x) => ce.power(x, expr.op2))).simplify();
+            return ce.mul(expr.op1.ops.map((x) => ce.pow(x, expr.op2))).simplify();
         if (op1head === 'Negate') {
             const n = asSmallInteger(expr.op2);
             if (n !== null && n > 0) {
                 if (n % 2 === 0)
-                    return ce.power(expr.op1.op1, expr.op2).simplify();
-                return ce.negate(ce.power(expr.op1.op1, expr.op2)).simplify();
+                    return ce.pow(expr.op1.op1, expr.op2).simplify();
+                return ce.neg(ce.pow(expr.op1.op1, expr.op2)).simplify();
             }
         }
         if (op1head === 'Add') {
@@ -15522,7 +15278,7 @@ function expand(expr) {
             if (n !== null) {
                 if (n > 0)
                     return expandN(expr.op1, n).simplify();
-                return ce.inverse(expandN(expr.op1, -n)).simplify();
+                return ce.inv(expandN(expr.op1, -n)).simplify();
             }
         }
     }
@@ -15641,9 +15397,7 @@ const UNIVARIATE_ROOTS = [
 function findUnivariateRoots(expr, x) {
     const ce = expr.engine;
     if (expr.head === 'Equal') {
-        expr = ce
-            .add([expr.op1.canonical, ce.negate(expr.op2.canonical)])
-            .simplify();
+        expr = ce.add([expr.op1.canonical, ce.neg(expr.op2.canonical)]).simplify();
     }
     const rules = ce.cache('univariate-roots-rules', () => boxRules(ce, UNIVARIATE_ROOTS));
     const result = matchRules(expand(expr).subs({ [x]: '_x' }, { canonical: false }), rules, { _x: ce.symbol('_x') });
@@ -15687,27 +15441,27 @@ function assume(proposition) {
 function assumeEquality(proposition) {
     console.assert(proposition.head === 'Equal');
     // Four cases:
-    // 1/ proposition contains no free variable without value
+    // 1/ proposition contains no free variables
     //    e.g. `2 + 1 = 3`, `\pi + 1 = \pi`
     //    => evaluate and return
-    // 2/ lhs is a single free variable with no value and `rhs` does not
-    //     contain `lhs`
+    // 2/ lhs is a single free variable and `rhs` does not contain `lhs`
     //    e.g. `x = 2`, `x = 2\pi`
     //    => if `lhs` has a definition, set its value to `rhs`, otherwise
     //          define a new symbol with a value of `rhs`
-    // 3/ proposition contains a single free variable without value
+    // 3/ proposition contains a single free variable
     //    => solve for the free variable, create new def or set value of the
     //      free variable with the root(s) as value
-    // 4/ proposition contains multiple free variables with no value
+    // 4/ proposition contains multiple free variables
     //    => add (lhs - rhs = 0) to assumptions DB
     // Case 1
-    const unvals = unvaluedIdentifiers(proposition);
-    if (unvals.length === 0) {
+    const freeVars = proposition.freeVars;
+    if (freeVars.length === 0) {
         const val = proposition.evaluate();
         if (val.symbol === 'True')
             return 'tautology';
         if (val.symbol === 'False')
             return 'contradiction';
+        console.log(proposition.canonical.evaluate());
         return 'not-a-predicate';
     }
     const ce = proposition.engine;
@@ -15728,17 +15482,14 @@ function assumeEquality(proposition) {
         return 'ok';
     }
     // Case 3
-    if (unvals.length === 1) {
-        const lhs = unvals[0];
+    if (freeVars.length === 1) {
+        const lhs = freeVars[0];
         const sols = findUnivariateRoots(proposition, lhs);
         if (sols.length === 0) {
             ce.assumptions.set(ce.box([
                 'Equal',
                 ce
-                    .add([
-                    proposition.op1.canonical,
-                    ce.negate(proposition.op2.canonical),
-                ])
+                    .add([proposition.op1.canonical, ce.neg(proposition.op2.canonical)])
                     .simplify(),
                 0,
             ]), true);
@@ -15759,17 +15510,16 @@ function assumeEquality(proposition) {
 }
 function assumeInequality(proposition) {
     //
-    // 1/ lhs is a single free var with no def
-    //    e.g. x < 0
+    // 1/ lhs is a single **undefined** free var e.g. "x < 0"
     //    => define a new var, if the domain can be inferred set it, otherwise
     // RealNumber and add to assumptions (e.g. x < 5)
-    // 2/ (lhs - rhs) is an expression with no free var with no value
-    //  e.g. \pi < 5
+    // 2/ (lhs - rhs) is an expression with no free vars
+    //  e.g. "\pi < 5"
     //  => evaluate
-    // 3/ (lhs - rhs) is an expression with a single free var with no value
-    //    e.g. x + 1 < \pi
+    // 3/ (lhs - rhs) is an expression with a single **undefined** free var
+    //    e.g. "x + 1 < \pi"
     //    => add def as RealNumber, add to assumptions
-    // 4/ (lhs - rhs) is an expression with multiple free vars with no value
+    // 4/ (lhs - rhs) is an expression with multiple free vars
     //    e.g. x + y < 0
     //    => add to assumptions
     const ce = proposition.engine;
@@ -15805,6 +15555,7 @@ function assumeInequality(proposition) {
         }
         return 'ok';
     }
+    // @todo: handle if proposition.op1 *has* a def (and no value)
     // Normalize to Less, LessEqual
     let op = '';
     let lhs;
@@ -15831,20 +15582,20 @@ function assumeInequality(proposition) {
     }
     if (!op)
         return 'internal-error';
-    const p = ce.add([lhs.canonical, ce.negate(rhs.canonical)]).simplify();
-    const unvals = unvaluedIdentifiers(p);
+    const p = ce.add([lhs.canonical, ce.neg(rhs.canonical)]).simplify();
     // Case 2
     const result = ce.box([op === '<' ? 'Less' : 'LessEqual', p, 0]).evaluate();
-    if (unvals.length === 0) {
-        if (result.symbol === 'True')
-            return 'tautology';
-        if (result.symbol === 'False')
-            return 'contradiction';
+    if (result.symbol === 'True')
+        return 'tautology';
+    if (result.symbol === 'False')
+        return 'contradiction';
+    const freeVars = result.freeVars;
+    if (freeVars.length === 0)
         return 'not-a-predicate';
-    }
     // Case 3
-    if (unvals.length === 1) {
-        ce.defineSymbol(unvals[0], { domain: 'ExtendedRealNumber' });
+    if (freeVars.length === 1) {
+        if (!ce.lookupSymbol(freeVars[0]))
+            ce.defineSymbol(freeVars[0], { domain: 'ExtendedRealNumber' });
     }
     // Case 3, 4
     console.assert(result.head === 'Less' || result.head === 'LessEqual');
@@ -15916,20 +15667,7 @@ function hasDef(ce, s) {
     return (ce.lookupSymbol(s) ?? ce.lookupFunction(s)) !== undefined;
 }
 function undefinedIdentifiers(expr) {
-    const syms = expr.symbols;
-    if (syms.length === 0)
-        return [];
-    return syms
-        .filter((x) => !hasDef(expr.engine, x.symbol))
-        .map((x) => x.symbol);
-}
-function unvaluedIdentifiers(expr) {
-    const syms = expr.symbols;
-    if (syms.length === 0)
-        return [];
-    return syms
-        .filter((x) => !hasValue(expr.engine, x.symbol))
-        .map((x) => x.symbol);
+    return expr.symbols.filter((x) => !hasDef(expr.engine, x));
 }
 function hasValue(ce, s) {
     if (ce.lookupFunction(s))
@@ -15941,20 +15679,7 @@ function isInequality(expr) {
     if (typeof h !== 'string')
         return false;
     return ['Less', 'Greater', 'LessEqual', 'GreaterEqual'].includes(h);
-}
-// export function getAssumptionsAbout(
-//   ce: ComputeEngineInterface,
-//   symbol: string
-// ): BoxedExpression[] {
-//   const result: BoxedExpression[] = [];
-//   for (const [assumption, val] of ce.assumptions) {
-//     const vars = getVars(assumption);
-//     if (vars.includes(symbol)) {
-//       result.push(val ? assumption : ce.boxFunction('Not', [assumption]));
-//     }
-//   }
-//   return [];
-// }
+}
 
 /**
  * AbstractBoxedExpression
@@ -16044,7 +15769,14 @@ class AbstractBoxedExpression {
         return this.getSubexpressions('');
     }
     get symbols() {
-        return [...getSymbols(this, new Set())].map((x) => this.engine.symbol(x, { canonical: false }));
+        const set = new Set();
+        getSymbols(this, set);
+        return Array.from(set);
+    }
+    get freeVars() {
+        const set = new Set();
+        getFreeVars(this, set);
+        return Array.from(set);
     }
     get errors() {
         return this.getSubexpressions('Error');
@@ -16274,6 +16006,132 @@ class AbstractBoxedExpression {
     }
 }
 
+function factorial(ce, n) {
+    if (!n.isInteger() || n.isNegative())
+        return ce._BIGNUM_NAN;
+    if (n.lessThan(10))
+        return ce.bignum([1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800][n.toNumber()]);
+    if (n.gt(Number.MAX_SAFE_INTEGER)) {
+        let val = ce._BIGNUM_ONE;
+        let i = ce._BIGNUM_TWO;
+        while (i.lessThan(n)) {
+            val = val.mul(i);
+            i = i.add(1);
+        }
+        return val;
+    }
+    if (n.modulo(2).eq(1)) {
+        return n.times(factorial(ce, n.minus(1)));
+    }
+    let loop = n.toNumber();
+    let sum = n;
+    let val = n;
+    while (loop > 2) {
+        loop -= 2;
+        sum = sum.add(loop);
+        val = val.mul(sum);
+    }
+    return val;
+}
+const gammaG = 7;
+// Spouge approximation (suitable for large arguments)
+function lngamma$1(ce, z) {
+    if (z.isNegative())
+        return ce._BIGNUM_NAN;
+    const GAMMA_P_LN = ce.cache('gamma-p-ln', () => {
+        return [
+            '0.99999999999999709182',
+            '57.156235665862923517',
+            '-59.597960355475491248',
+            '14.136097974741747174',
+            '-0.49191381609762019978',
+            '0.33994649984811888699e-4',
+            '0.46523628927048575665e-4',
+            '-0.98374475304879564677e-4',
+            '0.15808870322491248884e-3',
+            '-0.21026444172410488319e-3',
+            '0.2174396181152126432e-3',
+            '-0.16431810653676389022e-3',
+            '0.84418223983852743293e-4',
+            '-0.2619083840158140867e-4',
+            '0.36899182659531622704e-5',
+        ].map((x) => ce.bignum(x));
+    });
+    let x = GAMMA_P_LN[0];
+    for (let i = GAMMA_P_LN.length - 1; i > 0; --i) {
+        x = x.add(GAMMA_P_LN[i].div(z.add(i)));
+    }
+    const GAMMA_G_LN = ce.cache('gamma-g-ln', () => ce.bignum(607).div(128));
+    const t = z.add(GAMMA_G_LN).add(ce._BIGNUM_HALF);
+    return ce._BIGNUM_NEGATIVE_ONE
+        .acos()
+        .mul(ce._BIGNUM_TWO)
+        .log()
+        .mul(ce._BIGNUM_HALF)
+        .add(t.log().mul(z.add(ce._BIGNUM_HALF)).minus(t).add(x.log()).minus(z.log()));
+}
+// From https://github.com/substack/gamma.js/blob/master/index.js
+function gamma$1(ce, z) {
+    if (z.lessThan(ce._BIGNUM_HALF)) {
+        const pi = ce._BIGNUM_NEGATIVE_ONE.acos();
+        return pi.div(pi
+            .mul(z)
+            .sin()
+            .mul(gamma$1(ce, ce._BIGNUM_ONE.sub(z))));
+    }
+    if (z.greaterThan(100))
+        return lngamma$1(ce, z).exp();
+    z = z.sub(1);
+    // coefficients for gamma=7, kmax=8  Lanczos method
+    // Source: GSL/specfunc/gamma.c
+    const LANCZOS_7_C = ce.cache('lanczos-7-c', () => {
+        return [
+            '0.99999999999980993227684700473478',
+            '676.520368121885098567009190444019',
+            '-1259.13921672240287047156078755283',
+            '771.3234287776530788486528258894',
+            '-176.61502916214059906584551354',
+            '12.507343278686904814458936853',
+            '-0.13857109526572011689554707',
+            '9.984369578019570859563e-6',
+            '1.50563273514931155834e-7',
+        ].map((x) => ce.bignum(x));
+    });
+    let x = LANCZOS_7_C[0];
+    for (let i = 1; i < gammaG + 2; i++)
+        x = x.add(LANCZOS_7_C[i].div(z.add(i)));
+    const t = z.add(gammaG).add(ce._BIGNUM_HALF);
+    return ce._BIGNUM_NEGATIVE_ONE
+        .acos()
+        .times(ce._BIGNUM_TWO)
+        .sqrt()
+        .mul(x.mul(t.neg().exp()).mul(t.pow(z.add(ce._BIGNUM_HALF))));
+}
+/**
+ * If the exponent of the bignum is in the range of the exponents
+ * for machine numbers,return true.
+ */
+function isInMachineRange(d) {
+    if (!d.isFinite())
+        return true; // Infinity and NaN are in machine range
+    // Are there too many significant digits?
+    // Maximum Safe Integer is 9007199254740991
+    // Digits in Decimal are stored by blocks of 7.
+    // Three blocks, with the first block = 90 is close to the maximum
+    if (d.d.length > 3 || (d.d.length === 3 && d.d[0] >= 90))
+        return false;
+    console.assert(d.precision() <= 16);
+    // Is the exponent within range?
+    // With a binary 64 IEEE 754 number:
+    // significant bits: 53 -> 15 digits
+    // exponent bits: 11. emax = 307, emin = -306)
+    return d.e < 308 && d.e > -306;
+}
+// export function asMachineNumber(d: Decimal): number | null {
+//   if (d.precision() < 15 && d.e < 308 && d.e > -306) return d.toNumber();
+//   return null;
+// }
+
 /**
  * The total degree of an expression is the sum of the
  * of the positive integer degrees of the factors in the expression:
@@ -16326,11 +16184,15 @@ function maxDegree(expr) {
 function lex(expr) {
     if (expr.symbol)
         return expr.symbol;
-    if (expr.ops)
-        return expr.ops
-            .map((x) => lex(x))
-            .filter((x) => x.length > 0)
-            .join('"');
+    if (expr.ops) {
+        const h = typeof expr.head === 'string' ? expr.head : lex(expr.head);
+        return (h +
+            '"' +
+            expr.ops
+                .map((x) => lex(x))
+                .filter((x) => x.length > 0)
+                .join('"'));
+    }
     return '';
 }
 
@@ -16343,6 +16205,12 @@ function sortAdd(ce, ops) {
     return ops.sort((a, b) => {
         const aLex = lex(a);
         const bLex = lex(b);
+        if (!aLex && !bLex)
+            return order(a, b);
+        if (!aLex)
+            return +1;
+        if (!bLex)
+            return -1;
         if (aLex < bLex)
             return -1;
         if (aLex > bLex)
@@ -16395,7 +16263,11 @@ function sortAdd(ce, ops) {
  *
  */
 function order(a, b) {
-    console.assert(a.isCanonical && b.isCanonical);
+    // console.assert(a.isCanonical && b.isCanonical);
+    if (a === b)
+        return 0;
+    if (a.numericValue !== null && a.numericValue === b.numericValue)
+        return 0;
     //
     //  1/ Literal numeric values
     //
@@ -16423,6 +16295,17 @@ function order(a, b) {
             return +1;
         return -1;
     }
+    if (a.numericValue) {
+        if (b.numericValue) {
+            return +1;
+        }
+        return -1;
+    }
+    if (a.head === 'Sqrt' && a.op1.numericValue) {
+        if (b.head === 'Sqrt' && b.op1.numericValue)
+            return order(a.op1, b.op1);
+        return -1;
+    }
     //
     // 3/ Symbols
     //
@@ -16540,9 +16423,7 @@ class Product {
         this._isCanonical = options.canonical;
         this.engine = ce;
         this._sign = 1;
-        this._rational = bignumPreferred(ce)
-            ? [ce._BIGNUM_ONE, ce._BIGNUM_ONE]
-            : [1, 1];
+        this._rational = bignumPreferred(ce) ? [BigInt(1), BigInt(1)] : [1, 1];
         // this._squareRootRational = this._rational;
         this._complex = Complex.ONE;
         this._bignum = ce._BIGNUM_ONE;
@@ -16573,16 +16454,14 @@ class Product {
      */
     addTerm(term) {
         console.assert(term.isCanonical);
+        if (term.head === 'Multiply') {
+            for (const t of term.ops)
+                this.addTerm(t);
+            return;
+        }
         if (this._isCanonical) {
             if (term.isNothing)
                 return;
-            // if (term.head === 'Sqrt') {
-            //   const r = asRational(term.op1);
-            //   if (r) {
-            //     this._squareRootRational = mul(this._squareRootRational, r);
-            //     return;
-            //   }
-            // }
             // If we're calculation a canonical  product, fold exact literals into
             // running terms
             if (term.numericValue !== null) {
@@ -16622,10 +16501,7 @@ class Product {
                         num = num.neg();
                     }
                     if (num.isInteger())
-                        this._rational = mul(this._rational, [
-                            num,
-                            this.engine._BIGNUM_ONE,
-                        ]);
+                        this._rational = mul(this._rational, [bigint(num), BigInt(1)]);
                     else if (bignumPreferred(this.engine))
                         this._bignum = this._bignum.mul(num);
                     else
@@ -16670,6 +16546,11 @@ class Product {
                 rest = rest.op1;
             }
         }
+        else if (rest.head === 'Divide') {
+            this.addTerm(rest.op1);
+            exponent = [-1, 1];
+            rest = rest.op2;
+        }
         // Look for the base, and add the exponent if already in the list of terms
         let found = false;
         for (const x of this._terms) {
@@ -16692,25 +16573,12 @@ class Product {
                 let b = ce._BIGNUM_ONE;
                 if (!isRationalOne(this._rational)) {
                     if (isBigRational(this._rational))
-                        b = this._rational[0].div(this._rational[1]);
+                        b = ce
+                            .bignum(this._rational[0].toString())
+                            .div(ce.bignum(this._rational[1].toString()));
                     else
                         b = ce.bignum(this._rational[0]).div(this._rational[1]);
                 }
-                // if (!isRationalOne(this._squareRootRational)) {
-                //   if (isBigRational(this._squareRootRational))
-                //     b = b.mul(
-                //       this._squareRootRational[0]
-                //         .div(this._squareRootRational[1])
-                //         .sqrt()
-                //     );
-                //   else
-                //     b = b.mul(
-                //       ce
-                //         .bignum(this._squareRootRational[0])
-                //         .div(this._squareRootRational[1])
-                //         .sqrt()
-                //     );
-                // }
                 b = b.mul(this._bignum).mul(this._sign * this._number);
                 if (this._complex.im !== 0) {
                     const z = this._complex.mul(b.toNumber());
@@ -16727,21 +16595,10 @@ class Product {
             let n = 1;
             if (!isRationalOne(this._rational)) {
                 if (isBigRational(this._rational))
-                    n = this._rational[0].toNumber() / this._rational[1].toNumber();
+                    n = Number(this._rational[0]) / Number(this._rational[1]);
                 else
                     n = this._rational[0] / this._rational[1];
             }
-            // if (!isRationalOne(this._squareRootRational)) {
-            //   if (isBigRational(this._squareRootRational))
-            //     n *= Math.sqrt(
-            //       this._squareRootRational[0].toNumber() /
-            //         this._squareRootRational[1].toNumber()
-            //     );
-            //   else
-            //     n *= Math.sqrt(
-            //       this._squareRootRational[0] / this._squareRootRational[1]
-            //     );
-            // }
             n *= this._sign * this._number * this._bignum.toNumber();
             if (this._complex.im !== 0) {
                 const z = this._complex.mul(n);
@@ -16779,7 +16636,7 @@ class Product {
             if (mode === 'rational') {
                 if (machineNumerator(this._rational) !== 1) {
                     if (isBigRational(this._rational))
-                        b = b.mul(this._rational[0]);
+                        b = b.mul(ce.bignum(this._rational[0]));
                     else
                         n *= this._rational[0];
                 }
@@ -16798,19 +16655,6 @@ class Product {
                     unitTerms.push(ce.number(this._rational));
             }
         }
-        // if (!isRationalOne(this._squareRootRational)) {
-        //   if (mode === 'rational') {
-        //     if (machineNumerator(this._squareRootRational) !== 1)
-        //       unitTerms.push(ce.sqrt(ce.number(this._squareRootRational[0])));
-        //     if (machineDenominator(this._squareRootRational) !== 1)
-        //       xs.push({
-        //         exponent: [-1, 1],
-        //         terms: [ce.sqrt(ce.number(this._squareRootRational[1]))],
-        //       });
-        //   } else {
-        //     unitTerms.push(ce.sqrt(ce.number(this._squareRootRational)));
-        //   }
-        // }
         // Literal
         if (!b.equals(ce._BIGNUM_ONE))
             unitTerms.push(ce.number(b.mul(n)));
@@ -16882,8 +16726,7 @@ class Product {
         });
         if (groupedTerms === null)
             return ce._NAN;
-        let terms = termsAsExpressions(ce, groupedTerms);
-        terms = flattenOps(terms, 'Multiply') ?? terms;
+        const terms = termsAsExpressions(ce, groupedTerms);
         if (terms.length === 0)
             return ce._ONE;
         if (terms.length === 1)
@@ -16898,8 +16741,7 @@ class Product {
         const xsNumerator = [];
         const xsDenominator = [];
         for (const x of xs)
-            if ((typeof x.exponent[0] === 'number' && x.exponent[0] >= 0) ||
-                (typeof x.exponent[0] !== 'number' && x.exponent[0].isPositive()))
+            if (x.exponent[0] >= 0)
                 xsNumerator.push(x);
             else
                 xsDenominator.push({
@@ -16907,16 +16749,13 @@ class Product {
                     terms: x.terms,
                 });
         const ce = this.engine;
-        let numeratorTerms = termsAsExpressions(ce, xsNumerator);
-        numeratorTerms = flattenOps(numeratorTerms, 'Multiply') ?? numeratorTerms;
+        const numeratorTerms = termsAsExpressions(ce, xsNumerator);
         let numerator = ce._ONE;
         if (numeratorTerms.length === 1)
             numerator = numeratorTerms[0];
         else if (numeratorTerms.length > 0)
             numerator = ce._fn('Multiply', numeratorTerms);
-        let denominatorTerms = termsAsExpressions(ce, xsDenominator);
-        denominatorTerms =
-            flattenOps(denominatorTerms, 'Multiply') ?? denominatorTerms;
+        const denominatorTerms = termsAsExpressions(ce, xsDenominator);
         let denominator = ce._ONE;
         if (denominatorTerms.length === 1)
             denominator = denominatorTerms[0];
@@ -16930,7 +16769,7 @@ class Product {
             if (denominator.isOne)
                 return numerator;
             if (denominator.isNegativeOne)
-                return this.engine.negate(numerator);
+                return this.engine.neg(numerator);
         }
         return this.engine._fn('Divide', [numerator, denominator]);
     }
@@ -16958,35 +16797,23 @@ function degreeOrder(a, b) {
     const keyB = degreeKey(b.exponent);
     if (keyA !== keyB)
         return keyA - keyB;
-    if (isBigRational(a.exponent) && isBigRational(b.exponent)) {
-        return a.exponent[0]
-            .div(a.exponent[1])
-            .sub(b.exponent[0].div(b.exponent[1]))
-            .toNumber();
-    }
-    if (isBigRational(a.exponent) && isMachineRational(b.exponent)) {
-        return a.exponent[0]
-            .div(a.exponent[1])
-            .sub(b.exponent[0] / b.exponent[1])
-            .toNumber();
-    }
-    if (isMachineRational(a.exponent) && isBigRational(b.exponent)) {
-        return b.exponent[0]
-            .div(b.exponent[1])
-            .add(-a.exponent[0] / a.exponent[1])
-            .toNumber();
-    }
-    return (a.exponent[0] / a.exponent[1] -
-        b.exponent[0] / b.exponent[1]);
+    const [a_n, a_d] = [
+        machineNumerator(a.exponent),
+        machineDenominator(a.exponent),
+    ];
+    const [b_n, b_d] = [
+        machineNumerator(b.exponent),
+        machineDenominator(b.exponent),
+    ];
+    return a_n / a_d - b_n / b_d;
 }
 function termsAsExpressions(ce, terms) {
-    terms = terms.sort(degreeOrder);
-    const result = terms.map((x) => {
-        const t = flattenOps(x.terms, 'Multiply') ?? x.terms;
+    const result = terms.sort(degreeOrder).map((x) => {
+        const t = flattenOps(x.terms, 'Multiply');
         const base = t.length <= 1 ? t[0] : ce._fn('Multiply', t.sort(order));
         if (isRationalOne(x.exponent))
             return base;
-        return ce.power(base, x.exponent);
+        return ce.pow(base, x.exponent);
     });
     return flattenOps(result, 'Multiply') ?? result;
 }
@@ -17045,7 +16872,7 @@ function serializeJsonCanonicalFunction(ce, head, args, metadata) {
             if (exp === 2 && !exclusions.includes('Square'))
                 return serializeJsonFunction(ce, 'Square', [args[0]], metadata);
             if (exp !== null && exp < 0 && !exclusions.includes('Divide')) {
-                return serializeJsonFunction(ce, 'Divide', [ce._ONE, exp === -1 ? args[0] : ce.power(args[0], -exp)], metadata);
+                return serializeJsonFunction(ce, 'Divide', [ce._ONE, exp === -1 ? args[0] : ce.pow(args[0], -exp)], metadata);
             }
             const r = args[1].numericValue;
             if (!exclusions.includes('Sqrt') && r === 0.5)
@@ -17328,17 +17155,17 @@ function repeatingDecimals(ce, s) {
         for (let j = 0; j <= MAX_REPEATING_PATTERN_LENGTH; j++) {
             const repetend = fractionalPart.substring(i, i + j + 1);
             const times = Math.floor((fractionalPart.length - prefix.length) / repetend.length);
-            if (times > 1) {
-                if ((prefix + repetend.repeat(times + 1)).startsWith(fractionalPart)) {
-                    // Found a repeating pattern
-                    // Aktually...
-                    if (repetend === '0') {
-                        if (lastDigit === '0')
-                            return wholepart + '.' + prefix + (exponent ?? '');
-                        return s;
-                    }
-                    return (wholepart + '.' + prefix + '(' + repetend + ')' + (exponent ?? ''));
+            if (times < 3)
+                break;
+            if ((prefix + repetend.repeat(times + 1)).startsWith(fractionalPart)) {
+                // Found a repeating pattern
+                // Aktually...
+                if (repetend === '0') {
+                    if (lastDigit === '0')
+                        return wholepart + '.' + prefix + (exponent ?? '');
+                    return s;
                 }
+                return (wholepart + '.' + prefix + '(' + repetend + ')' + (exponent ?? ''));
             }
         }
     }
@@ -17818,10 +17645,202 @@ const SIMPLIFY_RULES = [];
 //   return expr;
 // }
 
+function validateArgumentCount(ce, ops, count) {
+    if (ops.length === count)
+        return ops;
+    const xs = [...ops.slice(0, count)];
+    let i = Math.min(count, ops.length);
+    while (i < count) {
+        xs.push(ce.error('missing'));
+        i += 1;
+    }
+    while (i < ops.length) {
+        xs.push(ce.error('unexpected-argument', ops[i]));
+        i += 1;
+    }
+    return xs;
+}
+/**
+ * Validation of arguments is normally done by checking the signature of the
+ * function vs the arguments of the expression. However, we have a fastpath
+ * for some common operations (add, multiply, power, neg, etc...) that bypasses
+ * the regular checks. This is its replacements. Since all those fastpath
+ * functions are numeric (i.e. have numeric arguments and return a numeric
+ * value), we do a simple numeric check of all arguments, and verify we have
+ * the number of expected arguments.
+ */
+function validateNumericArgs(ce, ops, count) {
+    // @fastpath
+    if (!ce.strict)
+        return ops;
+    let xs;
+    if (count === undefined)
+        xs = ops;
+    else {
+        xs = [];
+        for (let i = 0; i <= Math.max(count - 1, ops.length - 1); i++) {
+            if (i > count - 1)
+                xs.push(ce.error('unexpected-argument', ops[i]));
+            else
+                xs.push(ops[i] !== undefined
+                    ? ce.box(ops[i])
+                    : ce.error(['missing', 'Number']));
+        }
+    }
+    return xs.map((op) => !op.isValid || op.isNumber
+        ? op
+        : ce.error(['incompatible-domain', 'Number', op.domain], op));
+}
+/** Return `null` if the `ops` match the sig. Otherwise, return an array
+ * of expressions indicating the mismatched arguments.
+ *
+ */
+function validateSignature(sig, ops, codomain) {
+    const ce = sig.engine;
+    // @fastpath
+    if (!ce.strict)
+        return ops;
+    const opsDomain = ops.map((x) => x.domain);
+    const targetSig = ce.domain([
+        'Function',
+        ...opsDomain,
+        codomain ?? 'Anything',
+    ]);
+    if (sig.isCompatible(targetSig))
+        return null;
+    //
+    // There was a problem:
+    // 1/ not enough arguments
+    // 2/ too many arguments
+    // 3/ incompatible argument domain
+    //
+    // Iterate over each arg, and replace with error expression when appropriate
+    //
+    const expectedArgs = sig.domainArgs.slice(0, -1);
+    const count = Math.max(expectedArgs.length, opsDomain.length);
+    let newOps = [];
+    let rest = [...ops];
+    for (let i = 0; i <= count - 1; i++)
+        [newOps, rest] = validateNextArgument(ce, expectedArgs[i], newOps, rest);
+    // Remove any 'Nothing' at the end
+    while (newOps.length > 0 && newOps[newOps.length - 1].symbol === 'Nothing')
+        newOps.pop();
+    return newOps;
+}
+function validateArgument(ce, arg, dom) {
+    if (dom === undefined)
+        return ce.error('unexpected-argument', arg);
+    if (arg === undefined)
+        return ce.error(['missing', dom]);
+    if (!arg.isValid)
+        return arg;
+    if (arg?.domain.isCompatible(dom))
+        return arg;
+    return ce.error(['incompatible-domain', dom, arg.domain], arg);
+}
+function validateNextArgument(ce, dom, matched, ops) {
+    let next = ops.shift();
+    if (dom === undefined)
+        return [[...matched, ce.error('unexpected-argument', next)], ops];
+    if (!Array.isArray(dom)) {
+        if (!next)
+            return [[...matched, ce.error(['missing', dom])], ops];
+        if (!next.domain.isCompatible(dom)) {
+            return [
+                [...matched, ce.error(['incompatible-domain', dom, next.domain], next)],
+                ops,
+            ];
+        }
+        return [[...matched, next], ops];
+    }
+    const ctor = dom[0];
+    if (next === undefined) {
+        //
+        // An expected argument is missing. Is that OK?
+        //
+        let valid = false;
+        if (ctor === 'Union') {
+            //  If an `Union`, was `Nothing` an option?
+            for (let k = 1; k <= dom.length - 1; k++) {
+                if (dom[k] === 'Nothing') {
+                    valid = true;
+                    break;
+                }
+            }
+        }
+        else if (ctor === 'Maybe')
+            valid = true;
+        if (valid)
+            return [[...matched, ce.symbol('Nothing')], ops];
+        return [[...matched, ce.error(['missing', dom])], ops];
+    }
+    if (ctor === 'Union') {
+        //
+        // We expect one of several domains. Check if at least one matches
+        //
+        let found = false;
+        for (let k = 1; k <= dom.length - 1; k++) {
+            if (next.domain.isCompatible(dom[k])) {
+                found = true;
+                break;
+            }
+        }
+        if (found)
+            return [[...matched, next], ops];
+        return [
+            [...matched, ce.error(['incompatible-domain', dom, next.domain], next)],
+            ops,
+        ];
+    }
+    if (ctor === 'Sequence') {
+        const seq = dom[1];
+        if (!next || !next.domain.isCompatible(seq)) {
+            return [
+                [...matched, ce.error(['incompatible-domain', seq, next.domain], next)],
+                ops,
+            ];
+        }
+        let done = false;
+        const result = [...matched, next];
+        while (!done) {
+            next = ops.shift();
+            if (!next)
+                done = false;
+            else if (!next.domain.isCompatible(seq)) {
+                ops.unshift(next);
+                done = false;
+            }
+            else
+                result.push(next);
+        }
+        return [result, ops];
+    }
+    if (ctor === 'Maybe') {
+        if (next === undefined || next.symbol === 'Nothing')
+            return [[...matched, ce.symbol('Nothing')], ops];
+        return validateNextArgument(ce, dom[1], matched, [next, ...ops]);
+    }
+    console.error('Unhandled ctor', ctor);
+    return [[...matched, next], ops];
+}
+function validateArguments(ce, args, doms) {
+    // Do a quick check for the common case where everything is as expected.
+    // Avoid allocating arrays and objects
+    if (args.length === doms.length &&
+        args.every((x, i) => x.domain.isCompatible(doms[i])))
+        return args;
+    const xs = [];
+    for (let i = 0; i <= doms.length - 1; i++)
+        xs.push(validateArgument(ce, args[i], doms[i]));
+    for (let i = doms.length; i <= args.length - 1; i++)
+        xs.push(ce.error('unexpected-argument', args[i]));
+    return xs;
+}
+
 /**
  * Considering an old (existing) expression and a new (simplified) one,
  * return the cheapest of the two, with a bias towards the new (which can
- * actually be a bit mor expensive than the old one, and still be picked).
+ * actually be a bit more expensive than the old one, and still be picked).
  */
 function cheapest(oldExpr, newExpr) {
     if (newExpr === null || newExpr === undefined)
@@ -17831,9 +17850,14 @@ function cheapest(oldExpr, newExpr) {
     const ce = oldExpr.engine;
     const boxedNewExpr = ce.box(newExpr);
     if (ce.costFunction(boxedNewExpr) <= 1.7 * ce.costFunction(oldExpr)) {
+        // console.log(
+        //   'Picked new' + boxedNewExpr.toString() + ' over ' + oldExpr.toString()
+        // );
         return boxedNewExpr;
     }
-    console.log('Cheapest: Rejected ', boxedNewExpr.toString(), 'in favor of ', oldExpr.toString()); // @debug
+    // console.log(
+    //   'Picked old ' + oldExpr.toString() + ' over ' + newExpr.toString()
+    // );
     return oldExpr;
 }
 /**
@@ -18340,10 +18364,16 @@ class BoxedFunction extends AbstractBoxedExpression {
         //
         if (!this.isValid)
             return this;
-        if (!this.isCanonical)
-            return this.canonical.simplify(options);
+        if (!this.isCanonical) {
+            const canonical = this.canonical;
+            if (!canonical.isCanonical || !canonical.isValid)
+                return this;
+            return canonical.simplify(options);
+        }
         //
         // 2/ Simplify the applicable operands
+        // @todo not clear if this is always the best strategy. Might be better to
+        // defer to the handler.
         //
         const def = this.functionDefinition;
         const tail = holdMap(this._ops, def?.hold ?? 'none', def?.associative ? def.name : '', (x) => x.simplify(options));
@@ -18371,6 +18401,9 @@ class BoxedFunction extends AbstractBoxedExpression {
         }
         if (!expr)
             expr = this.engine.fn(this._head, tail);
+        else
+            expr = cheapest(this.engine.fn(this._head, tail), expr);
+        expr = cheapest(this, expr);
         //
         // 5/ Apply rules, until no rules can be applied
         //
@@ -18405,7 +18438,7 @@ class BoxedFunction extends AbstractBoxedExpression {
         //   console.error('Iteration Limit reached simplifying', this.toJSON());
         // }
         // @debug-end
-        return expr;
+        return cheapest(this, expr);
     }
     evaluate(options) {
         //
@@ -18413,8 +18446,12 @@ class BoxedFunction extends AbstractBoxedExpression {
         //
         if (!this.isValid)
             return this;
-        if (!this.isCanonical)
-            return this.canonical.evaluate(options);
+        if (!this.isCanonical) {
+            const canonical = this.canonical;
+            if (!canonical.isCanonical || !canonical.isValid)
+                return this;
+            return canonical.evaluate(options);
+        }
         //
         // 2/ Evaluate the applicable operands
         //
@@ -18460,8 +18497,12 @@ class BoxedFunction extends AbstractBoxedExpression {
             return this._numericValue;
         if (this.engine.strict && !this.isValid)
             return this;
-        if (!this.isCanonical)
-            return this.canonical.N(options);
+        if (!this.isCanonical) {
+            const canonical = this.canonical;
+            if (!canonical.isCanonical || !canonical.isValid)
+                return this;
+            return canonical.N(options);
+        }
         //
         // 2/ Evaluate the applicable operands
         //
@@ -18510,11 +18551,11 @@ class BoxedFunction extends AbstractBoxedExpression {
 function makeNumericFunction(ce, head, semiOps, metadata) {
     let ops = [];
     if (head === 'Add' || head === 'Multiply')
-        ops = validateNumericArgs(ce, semiOps);
+        ops = validateNumericArgs(ce, flattenOps(flattenSequence(ce.canonical(semiOps)), head));
     else if (head === 'Negate' || head === 'Square' || head === 'Sqrt')
-        ops = validateNumericArgs(ce, semiOps, 1);
+        ops = validateNumericArgs(ce, flattenSequence(ce.canonical(semiOps)), 1);
     else if (head === 'Divide' || head === 'Power')
-        ops = validateNumericArgs(ce, semiOps, 2);
+        ops = validateNumericArgs(ce, flattenSequence(ce.canonical(semiOps)), 2);
     else
         return null;
     // If some of the arguments are not valid, make a non-canonical expression
@@ -18527,25 +18568,23 @@ function makeNumericFunction(ce, head, semiOps, metadata) {
     if (head === 'Add')
         return ce.add(ops, metadata);
     if (head === 'Negate')
-        return ce.negate(ops[0] ?? ce.error('missing'), metadata);
+        return ce.neg(ops[0] ?? ce.error('missing'), metadata);
     if (head === 'Multiply')
         return ce.mul(ops, metadata);
     if (head === 'Divide')
-        return ce.divide(ops[0], ops[1], metadata);
+        return ce.div(ops[0], ops[1], metadata);
     if (head === 'Power')
-        return ce.power(ops[0], ops[1], metadata);
+        return ce.pow(ops[0], ops[1], metadata);
     if (head === 'Square')
-        return ce.power(ops[0], ce.number(2), metadata);
+        return ce.pow(ops[0], ce.number(2), metadata);
     if (head === 'Sqrt') {
         const op = ops[0].canonical;
         if (isRational(op.numericValue))
             return new BoxedFunction(ce, 'Sqrt', [op], { metadata, canonical: true });
-        return ce.power(op, ce.number([1, 2]), metadata);
+        return ce.pow(op, ce._HALF, metadata);
     }
-    if (head === 'Pair')
-        return ce.pair(ops[0], ops[1], metadata);
-    if (head === 'Tuple')
-        return ce.tuple(ops, metadata);
+    // if (head === 'Pair') return ce.pair(ops[0], ops[1], metadata);
+    // if (head === 'Tuple') return ce.tuple(ops, metadata);
     return null;
 }
 function makeCanonicalFunction(ce, head, ops, metadata) {
@@ -18592,9 +18631,14 @@ function makeCanonicalFunction(ce, head, ops, metadata) {
     // the expression.
     //
     if (sig.canonical) {
-        const result = sig.canonical(ce, xs);
-        if (result)
-            return result;
+        try {
+            const result = sig.canonical(ce, xs);
+            if (result)
+                return result;
+        }
+        catch (e) {
+            console.error(e);
+        }
         return new BoxedFunction(ce, head, xs, { metadata, canonical: false });
     }
     //
@@ -18603,7 +18647,7 @@ function makeCanonicalFunction(ce, head, ops, metadata) {
     //
     xs = flattenSequence(xs);
     if (def.associative)
-        xs = flattenOps(xs, head) ?? xs;
+        xs = flattenOps(xs, head);
     // If some of the arguments are not valid, can't make a canonical expression
     if (!xs.every((x) => x.isValid))
         return new BoxedFunction(ce, head, xs, { metadata, canonical: false });
@@ -18667,12 +18711,31 @@ function holdMap(xs, skip, associativeHead, f) {
     if (xs.length === 0)
         return [];
     // f(a, f(b, c), d) -> f(a, b, c, d)
-    if (associativeHead)
-        xs = flattenOps(xs, associativeHead) ?? xs;
-    const result = [];
+    xs = flattenOps(xs, associativeHead);
     //
     // Apply the hold as necessary
     //
+    // @fastpath
+    if (skip === 'all')
+        return xs;
+    if (skip === 'none') {
+        const result = [];
+        for (const x of xs) {
+            const h = x.head;
+            if (h === 'Hold')
+                result.push(x);
+            else {
+                const op = h === 'ReleaseHold' ? x.op1 : x;
+                if (op) {
+                    const y = f(op);
+                    if (y !== null)
+                        result.push(y);
+                }
+            }
+        }
+        return flattenOps(result, associativeHead);
+    }
+    const result = [];
     for (let i = 0; i < xs.length; i++) {
         if (xs[i].head === 'Hold') {
             result.push(xs[i]);
@@ -18692,9 +18755,7 @@ function holdMap(xs, skip, associativeHead, f) {
             }
         }
     }
-    if (associativeHead)
-        return flattenOps(result, associativeHead) ?? result;
-    return result;
+    return flattenOps(result, associativeHead);
 }
 function applicable(skip, count, index) {
     if (skip === 'all')
@@ -18781,7 +18842,7 @@ function inferNumericDomain(value) {
     //
     // 4. Is it a rational? (machine or bignum)
     //
-    if (Array.isArray(value)) {
+    if (isRational(value)) {
         const [numer, denom] = value;
         // The value is a rational number
         console.assert(typeof numer !== 'number' ||
@@ -18905,8 +18966,8 @@ class BoxedNumber extends AbstractBoxedExpression {
             const [n, d] = value;
             console.assert(typeof n !== 'number' ||
                 (Number.isInteger(n) && Number.isInteger(d) && d !== n && d !== 1));
-            console.assert(!(n instanceof Decimal && d instanceof Decimal) ||
-                (n.isInteger() && d.isInteger() && !d.eq(n) && !d.eq(1)));
+            console.assert(!(typeof n === 'bigint' && typeof d == 'bigint') ||
+                (d !== n && d !== BigInt(1)));
             if (options?.canonical ?? true) {
                 this._value = canonicalNumber(ce, value);
                 this._isCanonical = true;
@@ -19304,7 +19365,7 @@ class BoxedNumber extends AbstractBoxedExpression {
             typeof denom === 'number' &&
             !bignumPreferred(ce))
             return ce.number(numer / denom);
-        return ce.number(ce.bignum(numer).div(denom));
+        return ce.number(ce.bignum(numer).div(ce.bignum(denom)));
     }
 }
 function canonicalNumber(ce, value) {
@@ -19315,31 +19376,30 @@ function canonicalNumber(ce, value) {
         return value.toNumber();
     if (!isRational(value))
         return value;
-    let [n, d] = value;
-    if (n instanceof Decimal && d instanceof Decimal) {
-        if (isInMachineRange(n) && isInMachineRange(d))
-            [n, d] = [n.toNumber(), d.toNumber()];
+    value = reducedRational(value);
+    if (isBigRational(value)) {
+        let [n, d] = value;
+        if (n > Number.MIN_SAFE_INTEGER &&
+            n < Number.MAX_SAFE_INTEGER &&
+            d > Number.MIN_SAFE_INTEGER &&
+            d < Number.MAX_SAFE_INTEGER)
+            value = [Number(n), Number(d)];
         else {
-            if (n.isNaN() || d.isNaN())
-                return NaN;
-            [n, d] = reducedRational([n, d]);
-            if (d.isNegative())
-                [n, d] = [n.neg(), d.neg()];
-            if (d.eq(ce._BIGNUM_ONE))
-                return n;
-            if (d.isZero()) {
-                if (n.isZero() || !n.isFinite())
+            if (d < 0)
+                [n, d] = [-n, -d];
+            if (d === BigInt(1))
+                return ce.bignum(n);
+            if (d === BigInt(0)) {
+                if (n === d)
                     return NaN;
-                if (n.isNegative())
-                    return -Infinity;
-                return +Infinity;
+                return n < 0 ? -Infinity : +Infinity;
             }
             return [n, d];
         }
     }
+    let [n, d] = value;
     if (Number.isNaN(n) || Number.isNaN(d))
         return NaN;
-    [n, d] = reducedRational([n, d]);
     if (d < 0)
         [n, d] = [-n, -d];
     if (d === 1)
@@ -19474,21 +19534,26 @@ function boxNumber(ce, num, options) {
     //
     // Do we have a rational or big rational?
     //
+    if (Array.isArray(num) &&
+        num.length === 2 &&
+        num[0] instanceof Decimal &&
+        num[1] instanceof Decimal) {
+        if (!num[0].isInteger() || !num[1].isInteger())
+            throw new Error('Array argument to `boxNumber()` should be two integers');
+        num = [bigint(num[0].toString()), bigint(num[1].toString())];
+    }
     if (isRational(num)) {
         if (num.length !== 2)
             throw new Error('Array argument to `boxNumber()` should be two integers or two bignums');
         const [n, d] = num;
-        if (n instanceof Decimal && d instanceof Decimal) {
-            // We have a big rational
-            if (!n.isInteger() || !d.isInteger())
-                throw new Error('Array argument to `boxNumber()` should be two integers');
-            if (n.eq(d))
-                return d.isZero() ? ce._NAN : ce._ONE;
-            if (d.eq(1))
+        if (typeof n === 'bigint' && typeof d === 'bigint') {
+            if (n === d)
+                return d === BigInt(0) ? ce._NAN : ce._ONE;
+            if (d === BigInt(1))
                 return ce.number(n, options);
-            if (d.eq(-1))
-                return ce.number(n.negated(), options);
-            if (n.eq(1) && d.eq(2))
+            if (d === BigInt(-1))
+                return ce.number(-n, options);
+            if (n === BigInt(1) && d === BigInt(2))
                 return ce._HALF;
             return new BoxedNumber(ce, [n, d], options);
         }
@@ -19633,16 +19698,16 @@ function boxFunction(ce, head, ops, options) {
     if ((head === 'Divide' || head === 'Rational') && ops.length === 2) {
         if (ops[0] instanceof AbstractBoxedExpression &&
             ops[1] instanceof AbstractBoxedExpression) {
-            const [n, d] = [asBignum(ops[0]), asBignum(ops[1])];
-            if (n?.isInteger() && d?.isInteger())
+            const [n, d] = [asBigint(ops[0]), asBigint(ops[1])];
+            if (n && d)
                 return ce.number([n, d], options);
         }
         else {
             const [n, d] = [
-                bignumValue(ce, ops[0]),
-                bignumValue(ce, ops[1]),
+                bigintValue(ce, ops[0]),
+                bigintValue(ce, ops[1]),
             ];
-            if (n?.isInteger() && d?.isInteger())
+            if (n && d)
                 return ce.number([n, d], options);
         }
         head = 'Divide';
@@ -19777,19 +19842,17 @@ function box(ce, expr, options) {
             // This wasn't a valid rational, turn it into a `Divide`
             return boxFunction(ce, 'Divide', expr, options);
         }
-        if (isBigRational(expr)) {
-            if (expr[0].isInteger() && expr[1].isInteger())
-                return ce.number(expr);
-            // This wasn't a valid rational, turn it into a `Divide`
-            return boxFunction(ce, 'Divide', expr, options);
-        }
+        if (isBigRational(expr))
+            return ce.number(expr);
         if (typeof expr[0] === 'string')
             return boxFunction(ce, expr[0], expr.slice(1), options);
         // It's a function with a head expression
         // Try to evaluate to something simpler
         const ops = expr.slice(1).map((x) => box(ce, x, options));
-        const head = apply$1(box(ce, expr[0], options), ops);
-        return head.symbol ? new BoxedFunction(ce, head.symbol, ops) : head;
+        const head = box(ce, expr[0], options);
+        if (head.symbol)
+            return new BoxedFunction(ce, head.symbol, ops);
+        return apply$1(head, ops);
     }
     //
     // Box a number (other than a rational)
@@ -19867,20 +19930,21 @@ function lngamma(c) {
 
 class Sum {
     constructor(ce, xs, options) {
+        // If `false`, the running sums are not calculated
+        this._isCanonical = true;
         this._imaginary = 0; // integers only
         this._posInfinityCount = 0;
         this._negInfinityCount = 0;
+        this._naNCount = 0;
+        // Each term is factored as the product of a rational and an expression
+        // For now, only rationals are factored, so `1.2x + 2.5x` are not combined.
         this._terms = [];
-        // If `false`, the running sums are not calculated
-        this._isCanonical = true;
         options ?? (options = {});
         if (!('canonical' in options))
             options.canonical = true;
         this._isCanonical = options.canonical;
         this.engine = ce;
-        this._rational = bignumPreferred(ce)
-            ? [ce._BIGNUM_ZERO, ce._BIGNUM_ONE]
-            : [0, 1];
+        this._rational = bignumPreferred(ce) ? [BigInt(0), BigInt(1)] : [0, 1];
         this._bignum = ce._BIGNUM_ZERO;
         this._number = 0;
         if (xs)
@@ -19896,7 +19960,8 @@ class Sum {
             this._number === 0 &&
             this._bignum.isZero() &&
             this._negInfinityCount === 0 &&
-            this._posInfinityCount === 0);
+            this._posInfinityCount === 0 &&
+            this._naNCount === 0);
     }
     /**
      * Add a term to the sum.
@@ -19911,9 +19976,13 @@ class Sum {
      *  -> [['x', [3, 1]], ['y', [1, 5]]]
      */
     addTerm(term, c) {
+        if (term.isNothing)
+            return;
+        if (term.isNaN || (term.isImaginary && !complexAllowed(this.engine))) {
+            this._naNCount += 1;
+            return;
+        }
         if (this._isCanonical) {
-            if (term.isNothing)
-                return;
             if (term.numericValue !== null) {
                 if (term.isInfinity) {
                     if (term.isPositive)
@@ -19961,7 +20030,11 @@ class Sum {
                         else if (isMachineRational(c))
                             this._imaginary += (im * c[0]) / c[1];
                         else
-                            this._imaginary += c[0].mul(im).div(c[1]).toNumber();
+                            this._imaginary += this.engine
+                                .bignum(c[0])
+                                .mul(im)
+                                .div(this.engine.bignum(c[1]))
+                                .toNumber();
                         im = 0;
                     }
                     if (re === 0 && im === 0)
@@ -20017,25 +20090,27 @@ class Sum {
     }
     terms(mode) {
         const ce = this.engine;
+        if (this._naNCount > 0)
+            return [ce._NAN];
+        if (this._imaginary !== 0 && !complexAllowed(ce))
+            return [ce._NAN];
         if (this._posInfinityCount > 0 && this._negInfinityCount > 0)
             return [ce._NAN];
         if (this._posInfinityCount > 0)
             return [ce._POSITIVE_INFINITY];
         if (this._negInfinityCount > 0)
             return [ce._NEGATIVE_INFINITY];
-        if (this._imaginary !== 0 && !complexAllowed(ce))
-            return [ce._NAN];
         const xs = [];
         for (const { coef, term } of this._terms) {
             if (!isRationalZero(coef)) {
                 if (isRationalOne(coef))
                     xs.push(term);
                 else if (isRationalNegativeOne(coef))
-                    xs.push(ce.negate(term));
+                    xs.push(ce.neg(term));
                 else if (machineDenominator(coef) === 1)
                     xs.push(ce.mul([ce.number(coef[0]), term]));
                 else if (machineNumerator(coef) === 1)
-                    xs.push(ce.divide(term, ce.number(coef[1])));
+                    xs.push(ce.div(term, ce.number(coef[1])));
                 else
                     xs.push(ce.mul([ce.number(coef), term]));
             }
@@ -20044,7 +20119,7 @@ class Sum {
             if (bignumPreferred(this.engine)) {
                 let sum = this._bignum.add(this._number);
                 if (!isRationalZero(this._rational))
-                    sum = sum.add(ce.bignum(this._rational[0]).div(this._rational[1]));
+                    sum = sum.add(ce.bignum(this._rational[0]).div(ce.bignum(this._rational[1])));
                 if (this._imaginary !== 0)
                     xs.push(ce.number(ce.complex(sum.toNumber(), this._imaginary)));
                 else if (ce.chop(sum) !== 0)
@@ -20082,7 +20157,7 @@ class Sum {
                     xs.push(ce.number(this._number));
             }
         }
-        return flattenOps(xs, 'Add') ?? xs;
+        return flattenOps(xs, 'Add');
     }
     asExpression(mode) {
         const ce = this.engine;
@@ -21015,7 +21090,6 @@ function isEqual(lhs, rhs) {
  * */
 function canonicalAdd(ce, ops) {
     console.assert(ops.every((x) => x.isCanonical));
-    ops = flattenOps(flattenSequence(ops.map((x) => x.canonical)), 'Add') ?? ops;
     // Remove literal 0
     ops = ops.filter((x) => x.numericValue === null || !x.isZero);
     if (ops.length === 0)
@@ -21100,7 +21174,6 @@ function evalAdd(ce, ops, mode = 'evaluate') {
         if (!arg.isExact)
             mode = 'N';
     }
-    console.assert(flattenOps(ops, 'Add') === null);
     if (mode === 'N')
         ops = ops.map((x) => x.N());
     else
@@ -21163,7 +21236,7 @@ function evalSummation(ce, expr, range, mode) {
         lower = asSmallInteger(range.op2) ?? 1;
         upper = asSmallInteger(range.op3) ?? MAX_ITERATION;
     }
-    if (lower >= upper || upper - lower >= MAX_SYMBOLIC_TERMS)
+    if (mode !== 'N' && (lower >= upper || upper - lower >= MAX_SYMBOLIC_TERMS))
         return undefined;
     const savedContext = ce.context;
     ce.context = fn.scope ?? ce.context;
@@ -21193,9 +21266,7 @@ function evalSummation(ce, expr, range, mode) {
         ce.context = savedContext;
         return ce.add(terms).evaluate();
     }
-    let sum = bignumPreferred(ce)
-        ? [ce._BIGNUM_ZERO, ce._BIGNUM_ONE]
-        : [0, 1];
+    let sum = bignumPreferred(ce) ? [BigInt(1), BigInt(1)] : [0, 1];
     if (!fn.scope)
         for (let i = lower; i <= upper; i++) {
             const term = fn.N();
@@ -21216,7 +21287,7 @@ function evalSummation(ce, expr, range, mode) {
     ce.context = savedContext;
     if (isMachineRational(sum))
         return ce.number(sum[0] / sum[1]);
-    return ce.number(sum[0].div(sum[1]));
+    return ce.number(ce.bignum(sum[0]).div(ce.bignum(sum[1])));
 }
 
 // @todo: replace usage with asCoefficient():
@@ -21237,34 +21308,35 @@ function makePositive(expr) {
         return [-1, ce.number(ce.complex(-n.re, -n.im))];
     if (isMachineRational(n) && n[0] < 0)
         return [-1, ce.number([-n[0], n[1]])];
-    if (isBigRational(n) && n[0].isNegative())
-        return [-1, ce.number([n[0].neg(), n[1]])];
+    if (isBigRational(n) && n[0] < 0)
+        return [-1, ce.number([-n[0], n[1]])];
     return [1, expr];
 }
 function apply(expr, fn, bigFn, complexFn) {
     const n = expr.numericValue;
+    const ce = expr.engine;
     console.assert(n !== null);
     if (typeof n === 'number') {
-        if (bignumPreferred(expr.engine) && bigFn)
-            return expr.engine.chop(bigFn(expr.engine.bignum(n)));
-        return expr.engine.chop(fn(n));
+        if (bignumPreferred(ce) && bigFn)
+            return ce.chop(bigFn(ce.bignum(n)));
+        return ce.chop(fn(n));
     }
     if (n instanceof Decimal)
-        return expr.engine.chop(bigFn?.(n) ?? fn(n.toNumber()));
+        return ce.chop(bigFn?.(n) ?? fn(n.toNumber()));
     if (isMachineRational(n)) {
-        if (!bignumPreferred(expr.engine) || !bigFn)
-            return expr.engine.chop(fn(n[0] / n[1]));
-        return expr.engine.chop(bigFn(expr.engine.bignum(n[0]).div(n[1])));
+        if (!bignumPreferred(ce) || !bigFn)
+            return ce.chop(fn(n[0] / n[1]));
+        return ce.chop(bigFn(ce.bignum(n[0]).div(n[1])));
     }
     if (isBigRational(n)) {
         if (bigFn)
-            return expr.engine.chop(bigFn(n[0].div(n[1])));
-        return expr.engine.chop(fn(n[0].toNumber() / n[1].toNumber()));
+            return ce.chop(bigFn(ce.bignum(n[0]).div(ce.bignum(n[1]))));
+        return ce.chop(fn(Number(n[0]) / Number(n[1])));
     }
     if (n instanceof Complex) {
-        if (!complexFn || !complexAllowed(expr.engine))
+        if (!complexFn || !complexAllowed(ce))
             return NaN;
-        return expr.engine.chop(complexFn(n));
+        return ce.chop(complexFn(n));
     }
     debugger;
     return NaN;
@@ -21289,14 +21361,14 @@ function apply2(expr1, expr2, fn, bigFn, complexFn) {
     if (m1 instanceof Decimal)
         b1 = m1;
     else if (isBigRational(m1))
-        b1 = m1[0].div(m1[1]);
+        b1 = ce.bignum(m1[0]).div(ce.bignum(m1[1]));
     else if (m1 !== null && typeof m1 === 'number')
         b1 = ce.bignum(m1);
     let b2 = undefined;
     if (m2 instanceof Decimal)
         b2 = m2;
     else if (isBigRational(m2))
-        b2 = m2[0].div(m2[1]);
+        b1 = ce.bignum(m2[0]).div(ce.bignum(m2[1]));
     else if (m2 !== null && typeof m2 === 'number')
         b2 = ce.bignum(m2);
     if (b1 && b2)
@@ -21317,17 +21389,17 @@ function apply2N(expr1, expr2, fn, bigFn, complexFn) {
 
 /**
  *
- * Return `null` if there is no canonicalization necessary and the result is
- * simply `ce._fn('Power', [base, exponent])`
  */
 function canonicalPower(ce, base, exponent, metadata) {
-    base = validateArgument(ce, base?.canonical, 'Number');
-    exponent = validateArgument(ce, exponent?.canonical, 'Number');
     if (exponent.symbol === 'ComplexInfinity')
         return ce._NAN;
+    if (exponent.isZero)
+        return ce._ONE;
+    if (exponent.isOne)
+        return base;
+    if (exponent.isNegativeOne)
+        return ce.inv(base);
     if (exponent.numericValue !== null) {
-        if (exponent.isZero)
-            return ce._ONE;
         if (base.numericValue !== null) {
             const numBase = asFloat(base);
             //
@@ -21346,27 +21418,9 @@ function canonicalPower(ce, base, exponent, metadata) {
                 if (exponent.isNegative)
                     return ce._COMPLEX_INFINITY; //  Unsigned Infinity...
             }
-            if (exponent.isOne)
-                return base;
-            if (exponent.isNegativeOne) {
-                //  x^(-1)
-                // if (base.isOne) return ce._ONE;
-                // if (base.isNegativeOne) return ce._NEGATIVE_ONE;
-                if (numBase === 1)
-                    return ce._ONE;
-                if (numBase === -1)
-                    return ce._NEGATIVE_ONE;
-                if (base.isInfinity)
-                    return ce._ZERO;
-                const r = base.numericValue;
-                if (typeof r === 'number' && Number.isInteger(r))
-                    return ce.number([1, r], { metadata });
-                if (r instanceof Decimal && r.isInteger())
-                    return ce.number([ce._BIGNUM_ONE, r], { metadata });
-                if (isRational(r))
-                    return ce.number(inverse(r), { metadata });
-                return ce._fn('Power', [base, ce._NEGATIVE_ONE], metadata);
-            }
+            //  x^(-1)
+            if (exponent.isNegativeOne)
+                return ce.inv(base);
             // x^{0.5}, x^{1/2} -> Square Root
             const e = asFloat(exponent);
             if (e === 0.5 || e === -0.5) {
@@ -21382,9 +21436,12 @@ function canonicalPower(ce, base, exponent, metadata) {
                             return ce.number(e >= 0 ? coef : [1, coef]);
                         return ce.mul([
                             ce.number(coef),
-                            ce.power(ce.number(radicand), ce._HALF),
+                            ce._fn('Sqrt', [ce.number(radicand)]),
                         ]);
                     }
+                    if (e > 0)
+                        return ce._fn('Sqrt', [base], metadata);
+                    return ce.inv(ce._fn('Sqrt', [base]), metadata);
                 }
                 if (e > 0)
                     return ce._fn('Power', [base, ce._HALF], metadata);
@@ -21415,17 +21472,6 @@ function canonicalPower(ce, base, exponent, metadata) {
             }
             if (exponent.isInfinity && (base.isOne || base.isNegativeOne))
                 return ce._NAN;
-            const r = asRational(base);
-            if (r) {
-                const e = asSmallInteger(exponent);
-                if (e !== null) {
-                    if (e === -1)
-                        return ce.number(inverse(r));
-                    // if (e > 0) return ce.number([Math.pow(n, e), Math.pow(d, e)]);
-                    // return ce.number([Math.pow(d, -e), Math.pow(n, -e)]);
-                }
-                // @todo: could call factorPower to handle \sqrt and \sqrt[3]
-            }
         }
     }
     //
@@ -21436,7 +21482,7 @@ function canonicalPower(ce, base, exponent, metadata) {
         if (a !== null) {
             const b = asSmallInteger(base.op2);
             if (b !== null) {
-                return ce.power(base.op1, ce.number(a * b));
+                return ce.pow(base.op1, ce.number(a * b));
             }
         }
         if (base.op1.isNonNegative) {
@@ -21444,7 +21490,7 @@ function canonicalPower(ce, base, exponent, metadata) {
             if (ar) {
                 const br = asRational(base.op2);
                 if (br)
-                    return ce.power(base.op1, ce.number(mul(ar, br)));
+                    return ce.pow(base.op1, ce.number(mul(ar, br)));
             }
         }
     }
@@ -21453,9 +21499,9 @@ function canonicalPower(ce, base, exponent, metadata) {
     if (base.head === 'Multiply') {
         const e = asSmallInteger(exponent);
         if (e !== null)
-            return ce._fn('Multiply', base.ops.map((x) => ce.power(x, exponent))); // Don't call ce.mul() to avoid infinite loops
+            return ce._fn('Multiply', base.ops.map((x) => ce.pow(x, exponent))); // Don't call ce.mul() to avoid infinite loops
     }
-    return null;
+    return ce._fn('Power', [base, exponent], metadata);
 }
 function square(ce, base) {
     const num = base.numericValue;
@@ -21468,16 +21514,16 @@ function square(ce, base) {
     if (isMachineRational(num))
         return ce.number([num[1] * num[1], num[0] * num[0]]);
     if (isBigRational(num))
-        return ce.number([num[1].pow(2), num[0].pow(2)]);
+        return ce.number([num[1] * num[1], num[0] * num[0]]);
     if (base.head === 'Multiply')
         return ce._fn('Multiply', base.ops.map((x) => square(ce, x))); // Don't call ce.mul() to avoid infinite loops
     if (base.head === 'Power') {
         const exp = asSmallInteger(base.op2);
         if (exp !== null)
-            return ce.power(base.op1, ce.number(exp * 2));
-        return ce.power(base.op1, ce.mul([ce.number(2), base.op2]));
+            return ce.pow(base.op1, ce.number(exp * 2));
+        return ce.pow(base.op1, ce.mul([ce.number(2), base.op2]));
     }
-    return ce.power(base, ce.number(2));
+    return ce.pow(base, ce.number(2));
 }
 function numEvalPower(ce, base, exponent) {
     if (base.numericValue === null || exponent.numericValue === null)
@@ -21510,7 +21556,7 @@ function numEvalPower(ce, base, exponent) {
         if (invExp === 2) {
             if (bigBase.isNeg())
                 return complexAllowed(ce)
-                    ? ce.mul([ce._I, ce.number(bigBase.neg().sqrt())])
+                    ? ce.number(ce.complex(0, bigBase.neg().sqrt().toNumber()))
                     : ce._NAN;
             return ce.number(bigBase.sqrt());
         }
@@ -21548,9 +21594,7 @@ function numEvalPower(ce, base, exponent) {
 }
 function processPower(ce, base, exponent, mode) {
     if (base.head === 'Multiply') {
-        let c = bignumPreferred(ce)
-            ? [ce._BIGNUM_ONE, ce._BIGNUM_ONE]
-            : [1, 1];
+        let c = bignumPreferred(ce) ? [BigInt(1), BigInt(1)] : [1, 1];
         const xs = [];
         for (const op of base.ops) {
             const r = asRational(op);
@@ -21562,7 +21606,7 @@ function processPower(ce, base, exponent, mode) {
         if (!isRationalOne(c))
             return ce.mul([
                 processSqrt(ce, ce.number(c), mode) ?? ce._ONE,
-                ce.power(processPower(ce, ce.mul(xs), exponent, mode) ?? ce.mul(xs), exponent),
+                ce.pow(processPower(ce, ce.mul(xs), exponent, mode) ?? ce.mul(xs), exponent),
             ]);
     }
     if (base.head === 'Power') {
@@ -21577,7 +21621,7 @@ function processPower(ce, base, exponent, mode) {
                 return ce._ONE;
             if (isRationalOne(e))
                 return base.op1;
-            return ce.power(base.op1, e);
+            return ce.pow(base.op1, e);
         }
         if (mode === 'N') {
             const ef1 = asFloat(base.op2);
@@ -21588,7 +21632,7 @@ function processPower(ce, base, exponent, mode) {
                     return ce._ONE;
                 if (ef === 1)
                     return base.op1;
-                return ce.power(base.op1, ef);
+                return ce.pow(base.op1, ef);
             }
         }
     }
@@ -21605,28 +21649,24 @@ function processPower(ce, base, exponent, mode) {
             const [n, d] = [machineNumerator(r), machineDenominator(r)];
             if ((n === 1 || n === -1) && (d === 2 || d === 3)) {
                 if (bignumPreferred(ce) || base.numericValue instanceof Decimal) {
-                    const bigBase = asBignum(base);
-                    if (d % 2 === 0 && bigBase.isNeg() && !complexAllowed(ce))
+                    const bigBase = asBigint(base);
+                    if (d % 2 === 0 && bigBase < 0 && !complexAllowed(ce))
                         return ce._NAN;
-                    const sign = bigBase.isNegative()
-                        ? d % 2 === 0
-                            ? ce._I
-                            : ce._NEGATIVE_ONE
-                        : ce._ONE;
-                    const [factor, root] = factorPower(ce, bigBase.abs(), d);
-                    if (root.eq(1) && factor.eq(1))
+                    const sign = bigBase < 0 ? (d % 2 === 0 ? ce._I : ce._NEGATIVE_ONE) : ce._ONE;
+                    const [factor, root] = factorPower(bigBase > 0 ? bigBase : -bigBase, d);
+                    if (root === BigInt(1) && factor === BigInt(1))
                         return sign;
                     // If factor === 1, nothing special to do, fall through
-                    if (!factor.eq(1)) {
-                        if (root.eq(1))
+                    if (factor !== BigInt(1)) {
+                        if (root === BigInt(1))
                             return ce.mul([
                                 sign,
-                                ce.number(n >= 0 ? factor : [ce.bignum(1), factor]),
+                                ce.number(n >= 0 ? factor : [BigInt(1), factor]),
                             ]);
                         return ce.mul([
                             sign,
                             ce.number(factor),
-                            ce.power(ce.number(root), exponent),
+                            ce.pow(ce.number(root), exponent),
                         ]);
                     }
                 }
@@ -21648,7 +21688,7 @@ function processPower(ce, base, exponent, mode) {
                         return ce.mul([
                             sign,
                             ce.number(factor),
-                            ce.power(ce.number(root), exponent),
+                            ce.pow(ce.number(root), exponent),
                         ]);
                     }
                 }
@@ -21657,7 +21697,7 @@ function processPower(ce, base, exponent, mode) {
             if (base.isNegative) {
                 if (!complexAllowed)
                     return ce._NAN;
-                return ce.mul([ce._I, ce.fn('Sqrt', [ce.negate(base)])]);
+                return ce.mul([ce._I, ce.fn('Sqrt', [ce.neg(base)])]);
             }
             return undefined;
         }
@@ -21715,10 +21755,10 @@ function processSqrt(ce, base, mode) {
             }
         }
         if (isBigRational(r) || bignumPreferred(ce)) {
-            const n = ce.bignum(r[0]);
-            const [nFactor, nRoot] = factorPower(ce, n.abs(), 2);
-            const [dFactor, dRoot] = factorPower(ce, ce.bignum(r[1]), 2);
-            if (n.isNeg())
+            const n = bigint(r[0]);
+            const [nFactor, nRoot] = factorPower(n > 0 ? n : -n, 2);
+            const [dFactor, dRoot] = factorPower(bigint(r[1]), 2);
+            if (n < 0)
                 return ce.mul([
                     ce.number([nFactor, dFactor]),
                     ce.sqrt(ce.number([nRoot, dRoot])),
@@ -21770,9 +21810,6 @@ function rootExp(exponent) {
  */
 function canonicalMultiply(ce, ops) {
     console.assert(ops.every((x) => x.isCanonical));
-    // Apply associativity
-    ops =
-        flattenOps(flattenSequence(ops).map((x) => x.canonical), 'Multiply') ?? ops;
     if (ops.length === 0)
         return ce.number(1);
     if (ops.length === 1)
@@ -21788,7 +21825,7 @@ function canonicalMultiply(ce, ops) {
     return product.asExpression();
 }
 function simplifyMultiply(ce, ops) {
-    console.assert(flattenOps(ops, 'Multiply') === null);
+    console.assert(ops.every((x) => x.head !== 'Multiply'));
     const product = new Product(ce);
     for (let op of ops) {
         op = op.simplify();
@@ -21798,25 +21835,20 @@ function simplifyMultiply(ce, ops) {
     }
     return product.asExpression();
 }
-function fastEvalMultiply(ops) {
-    let prod = 1;
-    for (const op of ops) {
-        if (typeof op.numericValue !== 'number')
-            return null;
-        prod *= op.numericValue;
-    }
-    return prod;
-}
 function evalMultiply(ce, ops, mode = 'evaluate') {
     console.assert(ops.length > 1, 'evalMultiply(): no arguments');
     //
     // @fastpath
     //
-    if (mode === 'N' && ce.numericMode === 'machine') {
+    if (mode === 'N') {
         ops = ops.map((x) => x.N());
-        const result = fastEvalMultiply(ops);
-        if (result !== null)
-            return ce.number(result);
+        if (ce.numericMode === 'machine' &&
+            ops.every((x) => typeof x.numericValue === 'number')) {
+            let prod = 1;
+            for (const op of ops)
+                prod *= op.numericValue;
+            return ce.number(prod);
+        }
     }
     //
     // First pass: looking for early exits
@@ -21827,7 +21859,7 @@ function evalMultiply(ce, ops, mode = 'evaluate') {
         if (!op.isExact)
             mode = 'N';
     }
-    console.assert(flattenOps(ops, 'Multiply') === null);
+    console.assert(ops.every((x) => x.head !== 'Multiply'));
     if (mode === 'N')
         ops = ops.map((x) => x.N());
     else
@@ -21906,9 +21938,8 @@ function multiply2(op1, op2, metadata) {
             return ce._fn('Multiply', [c, t], metadata);
         }
     }
-    if (c.hash === t.hash && c.isSame(t)) {
+    if (c.hash === t.hash && c.isSame(t))
         return square(ce, c);
-    }
     const product = new Product(ce, [c, t]);
     if (sign > 0)
         return product.asExpression();
@@ -21984,9 +22015,7 @@ function evalMultiplication(ce, expr, range, mode) {
         const product = ce.mul(terms);
         return mode === 'simplify' ? product.simplify() : product.evaluate();
     }
-    let product = bignumPreferred(ce)
-        ? [ce._BIGNUM_ONE, ce._BIGNUM_ONE]
-        : [1, 1];
+    let product = bignumPreferred(ce) ? [BigInt(1), BigInt(1)] : [1, 1];
     for (let i = lower; i <= upper; i++) {
         const n = ce.number(i);
         const r = fn.subs({ _1: n, _: n });
@@ -21997,7 +22026,7 @@ function evalMultiplication(ce, expr, range, mode) {
     }
     if (isMachineRational(product))
         return ce.number(product[0] / product[1]);
-    return ce.number(product[0].div(product[1]));
+    return ce.number(ce.bignum(product[0]).div(ce.bignum(product[1])));
 }
 
 /**
@@ -22010,19 +22039,21 @@ function evalMultiplication(ce, expr, range, mode) {
  * - if Divide, transform into Multiply/Power
  */
 function canonicalDivide(ce, op1, op2) {
-    op1 = validateArgument(ce, op1, 'Number');
-    op2 = validateArgument(ce, op2, 'Number');
     if (!op1.isValid || !op2.isValid)
         return ce._fn('Divide', [op1, op2]);
+    if (op1.head === 'Negate' && op2.head === 'Negate') {
+        op1 = op1.op1;
+        op2 = op2.op1;
+    }
     if (op1.numericValue !== null && op2.numericValue !== null) {
         if (op2.isOne)
             return op1;
         if (op2.isNegativeOne)
-            return canonicalNegate(op1);
+            return ce.neg(op1);
         if (op1.isOne)
-            return ce.inverse(op2);
+            return ce.inv(op2);
         if (op1.isNegativeOne)
-            return canonicalNegate(ce.inverse(op2));
+            return ce.neg(ce.inv(op2));
         const r1 = asRational(op1);
         const r2 = asRational(op2);
         if (r1 && r2 && !isRationalZero(r2))
@@ -22058,6 +22089,10 @@ function canonicalDivide(ce, op1, op2) {
         return canonicalDivide(ce, ce.mul([op1.op1, op2]), op1.op2);
     if (op2.head === 'Divide' || op2.head === 'Rational')
         return canonicalDivide(ce, ce.mul([op1, op2.op2]), op2.op1);
+    const [c1, t1] = asCoefficient(op1);
+    const [c2, t2] = asCoefficient(op2);
+    if (!isRationalOne(c1) || !isRationalOne(c2))
+        return ce.mul([ce.number(mul(c1, inverse(c2))), ce.div(t1, t2)]);
     // eslint-disable-next-line prefer-const
     let [nSign, n] = makePositive(op1);
     // eslint-disable-next-line prefer-const
@@ -22066,17 +22101,11 @@ function canonicalDivide(ce, op1, op2) {
     d = d.canonical;
     if (d.numericValue !== null && d.isOne)
         return nSign * dSign < 0 ? canonicalNegate(n) : n;
-    // Divide: transform into multiply/power
-    d = ce.inverse(d);
-    if (n.numericValue !== null) {
-        if (n.isOne)
-            return d;
-        if (n.isNegativeOne)
-            return canonicalNegate(d);
-    }
     if (nSign * dSign > 0)
-        return ce.mul([n, d]);
-    return canonicalNegate(ce.mul([n, d]));
+        return ce._fn('Divide', [n, d]);
+    if (n.numericValue)
+        return ce._fn('Divide', [canonicalNegate(n), d]);
+    return canonicalNegate(ce._fn('Divide', [n, d]));
 }
 /**
  * Simplify form of 'Divide' (and 'Rational')
@@ -22088,7 +22117,11 @@ function simplifyDivide(ce, op1, op2) {
         if (r1 && r2 && !isRationalZero(r2))
             return ce.number(mul(r1, inverse(r2)));
     }
-    return undefined;
+    const [c1, t1] = asCoefficient(op1);
+    const [c2, t2] = asCoefficient(op2);
+    if (!isRationalOne(c1) || !isRationalOne(c2))
+        return ce.mul([ce.number(mul(c1, inverse(c2))), ce.div(t1, t2)]);
+    return new Product(ce, [op1, ce.inv(op2)]).asExpression();
 }
 
 // @todo Future additions to the dictionary
@@ -22146,7 +22179,7 @@ const ARITHMETIC_LIBRARY = [
             signature: {
                 domain: 'NumericFunction',
                 codomain: (ce, args) => domainAdd(ce, args.map((x) => x.domain)),
-                canonical: (ce, args) => canonicalAdd(ce, args),
+                // canonical: (ce, args) => canonicalAdd(ce, args), // never called: shortpath
                 simplify: (ce, ops) => simplifyAdd(ce, ops),
                 evaluate: (ce, ops) => evalAdd(ce, ops),
                 N: (ce, ops) => evalAdd(ce, ops, 'N'),
@@ -22182,8 +22215,17 @@ const ARITHMETIC_LIBRARY = [
             // i.e. √2x/2 -> 0.707x, 2/√2x -> 1.4142x
             signature: {
                 domain: ['Function', 'Number', 'Number', 'Number'],
-                canonical: (ce, args) => canonicalDivide(ce, args[0], args[1]),
+                canonical: (ce, args) => {
+                    args = validateArguments(ce, canonical(flattenSequence(args)), [
+                        'Number',
+                        'Number',
+                    ]);
+                    if (args.length !== 2)
+                        return ce._fn('Divide', args);
+                    return ce.div(args[0], args[1]);
+                },
                 simplify: (ce, args) => simplifyDivide(ce, args[0], args[1]),
+                evaluate: (ce, ops) => apply2N(ops[0], ops[1], (n, d) => n / d, (n, d) => n.div(d), (n, d) => n.div(d)),
             },
         },
         Exp: {
@@ -22193,7 +22235,14 @@ const ARITHMETIC_LIBRARY = [
             // Exp(x) -> e^x
             signature: {
                 domain: ['Function', 'Number', 'Number'],
-                canonical: (ce, args) => ce.power(ce.symbol('ExponentialE'), validateArgument(ce, args[0], 'Number')),
+                canonical: (ce, args) => {
+                    args = validateArguments(ce, canonical(flattenSequence(args)), [
+                        'Number',
+                    ]);
+                    if (args.length !== 1)
+                        return ce._fn('Power', args);
+                    return ce.pow(ce.symbol('ExponentialE'), args[0]);
+                },
             },
         },
         Erf: {
@@ -22266,21 +22315,15 @@ const ARITHMETIC_LIBRARY = [
             signature: {
                 domain: ['Function', 'Number', ['Maybe', 'Number'], 'Number'],
                 canonical: (ce, ops) => {
-                    ops = flattenSequence(ops);
+                    ops = canonical(flattenSequence(ops));
                     if (ops.length === 1)
-                        return ce._fn('Log', [
-                            validateArgument(ce, ops[0].canonical, 'Number'),
-                        ]);
+                        return ce._fn('Log', [validateArgument(ce, ops[0], 'Number')]);
                     if (ops.length === 2) {
-                        const base = validateArgument(ce, ops[1].canonical, 'Number');
+                        const arg = validateArgument(ce, ops[0], 'Number');
+                        const base = validateArgument(ce, ops[1], 'Number');
                         if (base.numericValue === 10)
-                            return ce._fn('Log', [
-                                validateArgument(ce, ops[0].canonical, 'Number'),
-                            ]);
-                        return ce._fn('Log', [
-                            validateArgument(ce, ops[0].canonical, 'Number'),
-                            base,
-                        ]);
+                            return ce._fn('Log', [arg]);
+                        return ce._fn('Log', [arg, base]);
                     }
                     return ce._fn('Log', validateArgumentCount(ce, ops, 2));
                 },
@@ -22382,7 +22425,10 @@ const ARITHMETIC_LIBRARY = [
             hold: 'all',
             signature: {
                 domain: 'NumericFunction',
-                canonical: (ce, args) => canonicalMultiply(ce, args),
+                // Never called: fastpath
+                // canonical: (ce, args) => {
+                //   return canonicalMultiply(ce, args);
+                // },
                 simplify: (ce, ops) => simplifyMultiply(ce, ops),
                 evaluate: (ce, ops) => evalMultiply(ce, ops),
                 N: (ce, ops) => evalMultiply(ce, ops, 'N'),
@@ -22412,7 +22458,14 @@ const ARITHMETIC_LIBRARY = [
                         return ce.domain(negDomain);
                     return arg;
                 },
-                canonical: (_ce, args) => canonicalNegate(args[0]),
+                canonical: (ce, args) => {
+                    args = validateArguments(ce, canonical(flattenSequence(args)), [
+                        'Number',
+                    ]);
+                    if (args.length !== 1)
+                        return ce._fn('Negate', args);
+                    return canonicalNegate(args[0]);
+                },
                 simplify: (ce, ops) => processNegate(ce, ops[0], 'simplify'),
                 evaluate: (ce, ops) => processNegate(ce, ops[0], 'evaluate'),
                 N: (ce, ops) => processNegate(ce, ops[0], 'N'),
@@ -22436,7 +22489,15 @@ const ARITHMETIC_LIBRARY = [
             complexity: 3500,
             signature: {
                 domain: ['Function', 'Number', 'Number', 'Number'],
-                canonical: (ce, args) => canonicalPower(ce, args[0], args[1]) ?? ce._fn('Power', args),
+                canonical: (ce, args) => {
+                    args = validateArguments(ce, canonical(flattenSequence(args)), [
+                        'Number',
+                        'Number',
+                    ]);
+                    if (args.length !== 2)
+                        return ce._fn('Power', args);
+                    return ce.pow(args[0], args[1]);
+                },
                 simplify: (ce, ops) => processPower(ce, ops[0], ops[1], 'simplify'),
                 evaluate: (ce, ops) => processPower(ce, ops[0], ops[1], 'evaluate'),
                 N: (ce, ops) => {
@@ -22471,6 +22532,7 @@ const ARITHMETIC_LIBRARY = [
                     'Number',
                 ],
                 // codomain: (ce, args) => domainAdd(ce, args),
+                // The 'body' and 'range' need to be interpreted by canonicalMultiplication(). Don't canonicalize them yet.
                 canonical: (ce, ops) => canonicalMultiplication(ce, ops[0], ops[1]),
                 simplify: (ce, ops) => evalMultiplication(ce, ops[0], ops[1], 'simplify'),
                 evaluate: (ce, ops) => evalMultiplication(ce, ops[0], ops[1], 'evaluate'),
@@ -22482,18 +22544,17 @@ const ARITHMETIC_LIBRARY = [
             signature: {
                 domain: ['Function', 'Number', ['Maybe', 'Number'], 'RationalNumber'],
                 canonical: (ce, args) => {
-                    args = flattenSequence(args);
+                    args = canonical(flattenSequence(args));
                     if (args.length === 0)
                         return ce._fn('Rational', [ce.error(['missing', 'Number'])]);
                     if (args.length === 1)
                         return ce._fn('Rational', [
-                            validateArgument(ce, args[0].canonical, 'ExtendedRealNumber'),
+                            validateArgument(ce, args[0], 'ExtendedRealNumber'),
                         ]);
-                    args =
-                        validateSignature(ce.domain(['Function', 'Integer', 'Integer', 'RationalNumber']), args) ?? args;
-                    if (args.length !== 2 || !args[0].isValid || !args[1].isValid)
+                    args = validateArguments(ce, args, ['Integer', 'Integer']);
+                    if (args.length !== 2)
                         return ce._fn('Rational', args);
-                    return canonicalDivide(ce, args[0], args[1]);
+                    return ce.div(args[0], args[1]);
                 },
                 simplify: (ce, ops) => {
                     if (ops.length !== 2)
@@ -22528,17 +22589,16 @@ const ARITHMETIC_LIBRARY = [
             signature: {
                 domain: ['Function', 'Number', 'Number', 'Number'],
                 canonical: (ce, args) => {
-                    args = flattenSequence(args);
+                    args = canonical(flattenSequence(args));
                     if (args.length > 2)
                         return ce._fn('Root', validateArgumentCount(ce, args, 2));
                     const [base, exp] = [
-                        validateArgument(ce, args[0]?.canonical, 'Number'),
-                        validateArgument(ce, args[1]?.canonical, 'Number'),
+                        validateArgument(ce, args[0], 'Number'),
+                        validateArgument(ce, args[1], 'Number'),
                     ];
                     if (!exp.isValid || !base.isValid)
                         return ce._fn('Root', [base, exp]);
-                    return (canonicalPower(ce, base, ce.inverse(exp)) ??
-                        ce._fn('Power', [base, ce.inverse(exp)]));
+                    return ce.pow(base, ce.inv(exp));
                 },
             },
         },
@@ -22596,8 +22656,12 @@ const ARITHMETIC_LIBRARY = [
             complexity: 3000,
             signature: {
                 domain: ['Function', 'Number', 'Number'],
-                canonical: (ce, args) => canonicalPower(ce, args[0], ce._HALF) ??
-                    ce._fn('Power', [args[0], ce._HALF]),
+                canonical: (ce, args) => {
+                    args = canonical(flattenSequence(args));
+                    if (args.length !== 1)
+                        return ce._fn('Sqrt', args);
+                    return ce.pow(args[0], ce._HALF);
+                },
                 simplify: (ce, ops) => processSqrt(ce, ops[0], 'simplify'),
                 evaluate: (ce, ops) => processSqrt(ce, ops[0], 'evaluate'),
                 N: (ce, ops) => processSqrt(ce, ops[0], 'N'),
@@ -22610,8 +22674,12 @@ const ARITHMETIC_LIBRARY = [
             complexity: 3100,
             signature: {
                 domain: ['Function', 'Number', 'Number'],
-                canonical: (ce, args) => canonicalPower(ce, args[0], ce.number(2)) ??
-                    ce._fn('Power', [args[0], ce.number(2)]),
+                canonical: (ce, args) => {
+                    args = canonical(flattenSequence(args));
+                    if (args.length !== 1)
+                        return ce._fn('Square', args);
+                    return ce.pow(args[0], ce.number(2));
+                },
             },
         },
         Subtract: {
@@ -22622,7 +22690,7 @@ const ARITHMETIC_LIBRARY = [
                 canonical: (ce, args) => {
                     // Not necessarily legal, but probably what was intended:
                     // ['Subtract', 'x'] -> ['Negate', 'x']
-                    args = flattenSequence(args.map((x) => x.canonical));
+                    args = canonical(flattenSequence(args));
                     if (args.length === 1)
                         return canonicalNegate(args[0]);
                     args = validateArgumentCount(ce, args, 2);
@@ -22630,7 +22698,7 @@ const ARITHMETIC_LIBRARY = [
                         return ce._fn('Subtract', args);
                     if (!args.every((x) => x.isValid))
                         return ce._fn('Subtract', args);
-                    return canonicalAdd(ce, [args[0], canonicalNegate(args[1])]);
+                    return ce.add([args[0], canonicalNegate(args[1])]);
                 },
             },
         },
@@ -22795,14 +22863,16 @@ function processAbs(ce, arg, mode) {
                 return ce.number(mode === 'N' ? Math.abs(num[0] / num[1]) : [Math.abs(num[0]), num[1]]);
             if (isBigRational(num)) {
                 const [n, d] = num;
-                return ce.number(mode === 'N' ? n.div(d).abs() : [n.abs(), d]);
+                return ce.number(mode === 'N'
+                    ? ce.bignum(n).div(ce.bignum(d)).abs()
+                    : [n > 0 ? n : -n, d]);
             }
         }
     }
     if (arg.isNonNegative)
         return arg;
     if (arg.isNegative)
-        return ce.negate(arg);
+        return ce.neg(arg);
     return undefined;
 }
 
@@ -22906,6 +22976,164 @@ const COLLECTIONS_LIBRARY = {
 // sort
 // contains / find
 
+function oneOf(xs) {
+    return xs[Math.floor(Math.random() * xs.length)];
+}
+function randomExpressionWithHead(head, level) {
+    if (head === 'Add' || head === 'Multiply') {
+        const ops = [];
+        let count = 1 + Math.floor(Math.random() * 12);
+        while (count > 0) {
+            ops.push(randomExpression(level + 1));
+            count -= 1;
+        }
+        return [head, ...ops];
+    }
+    if (head === 'Divide' || head === 'Power') {
+        return [head, randomExpression(level + 1), randomExpression(level + 1)];
+    }
+    if (head === 'Root') {
+        return [head, randomExpression(level + 1), randomExpression(10)];
+    }
+    if (head === 'trig')
+        return randomTrig();
+    return [head, randomExpression(level + 1)];
+}
+function randomTrig() {
+    return [
+        oneOf([
+            'Cos',
+            'Sin',
+            'Tan',
+            'Sinh',
+            'Arccos',
+            'Arsinh',
+            ['InverseFunction', 'Cos'],
+        ]),
+        oneOf([
+            'Pi',
+            '-1',
+            '0',
+            '1',
+            ['Divide', 'Pi', -5],
+            ['Multiply', -2, ['Divide', 'Pi', 11]],
+            ['Multiply', 'Half', 'Pi'],
+            ['Multiply', 5, 'Pi'],
+            ['Multiply', 12, 'Pi'],
+            ['Divide', 'Pi', 5],
+            ['Divide', 'Pi', 9],
+            ['Multiply', 5, ['Divide', 'Pi', 9]],
+            ['Multiply', 2, ['Divide', 'Pi', 11]],
+            ['Multiply', 2, ['Divide', 'Pi', 3]],
+        ]),
+    ];
+}
+function randomExpression(level) {
+    level ?? (level = 1);
+    if (level === 1) {
+        const h = oneOf([
+            'Add',
+            'Add',
+            'Add',
+            'Add',
+            'Add',
+            'Multiply',
+            'Multiply',
+            'Multiply',
+            'Multiply',
+            'Divide',
+            'Divide',
+            'Divide',
+            'Root',
+            'Sqrt',
+            'Subtract',
+            'Negate',
+            'trig',
+        ]);
+        return randomExpressionWithHead(h, 1);
+    }
+    if (level === 2) {
+        if (Math.random() > 0.5)
+            return randomExpression(3);
+        if (Math.random() > 0.75)
+            return randomExpression(1);
+        const h = oneOf([
+            'Multiply',
+            'Multiply',
+            'Add',
+            'Power',
+            'trig',
+            'Ln',
+            'Exp',
+        ]);
+        return randomExpressionWithHead(h, 2);
+    }
+    return oneOf([
+        -0.000012345,
+        -2,
+        -2,
+        -2,
+        -3,
+        -5,
+        -6,
+        -12,
+        -1.654e-57,
+        0,
+        0,
+        0.00012345,
+        1.654e-57,
+        1,
+        2,
+        2,
+        2,
+        2,
+        3,
+        3,
+        5,
+        5,
+        6,
+        6,
+        1234.5678,
+        5678.1234,
+        10,
+        15,
+        18,
+        30,
+        60,
+        1.234e57,
+        '123456789.12345678912345e200',
+        '987654321.12345678912345',
+        ['Rational', -6, 10],
+        ['Rational', -12, 15],
+        ['Rational', -15, 12],
+        ['Rational', 3, 5],
+        ['Rational', 12, 15],
+        ['Rational', 15, 12],
+        'ExponentialE',
+        'ImaginaryUnit',
+        ['Sqrt', 3],
+        ['Sqrt', 5],
+        ['Sqrt', 15],
+        ['Sqrt', 25],
+        ['Complex', -1.1, 1.1],
+        ['Complex', 4, 5],
+        'x',
+        'x',
+        'x',
+        'x',
+        ['Add', 'x', 1],
+        ['Divide', 'x', 3],
+        ['Square', 'x'],
+        ['Power', 'x', 3],
+        ['Power', 'x', 4],
+        ['Subtract', 'x', 1],
+        ['Add', 'x', 1],
+        'a',
+        'b',
+        'Pi',
+    ]);
+}
+
 //   // := assign 80 // @todo
 const CORE_LIBRARY = [
     {
@@ -22945,7 +23173,7 @@ const CORE_LIBRARY = [
             signature: {
                 domain: ['Function', 'Anything', ['Tuple', 'Anything']],
                 codomain: (ce, args) => ce.domain(['Tuple', args[0].domain]),
-                canonical: (ce, ops) => ce.tuple(validateArgumentCount(ce, ops.map((x) => x.canonical), 1)),
+                canonical: (ce, ops) => ce.tuple(validateArgumentCount(ce, canonical(ops), 1)),
             },
         },
         Pair: {
@@ -22959,7 +23187,7 @@ const CORE_LIBRARY = [
                     ['Tuple', 'Anything', 'Anything'],
                 ],
                 codomain: (ce, args) => ce.domain(['Tuple', args[0].domain, args[1].domain]),
-                canonical: (ce, ops) => ce.tuple(validateArgumentCount(ce, ops.map((x) => x.canonical), 2)),
+                canonical: (ce, ops) => ce.tuple(validateArgumentCount(ce, canonical(ops), 2)),
             },
         },
         Triple: {
@@ -22974,7 +23202,7 @@ const CORE_LIBRARY = [
                     ['Tuple', 'Anything', 'Anything', 'Anything'],
                 ],
                 codomain: (ce, args) => ce.domain(['Tuple', args[0].domain, args[1].domain, args[2].domain]),
-                canonical: (ce, ops) => ce.tuple(validateArgumentCount(ce, ops.map((x) => x.canonical), 3)),
+                canonical: (ce, ops) => ce.tuple(validateArgumentCount(ce, canonical(ops), 3)),
             },
         },
         Tuple: {
@@ -22986,7 +23214,7 @@ const CORE_LIBRARY = [
                     ['Sequence', 'Anything'],
                     ['Tuple', ['Sequence', 'Anything']],
                 ],
-                canonical: (ce, ops) => ce.tuple(ops.map((x) => x.canonical)),
+                canonical: (ce, ops) => ce.tuple(canonical(ops)),
                 codomain: (ce, args) => ce.domain(['Tuple', ...args.map((x) => x.domain)]),
             },
         },
@@ -23114,7 +23342,7 @@ const CORE_LIBRARY = [
             /** Return the domain of an expression */
             signature: {
                 domain: ['Function', 'Anything', 'Domain'],
-                canonical: (ce, ops) => ce.domain(validateArgumentCount(ce, ops.map((x) => x.canonical), 1)[0]),
+                canonical: (ce, ops) => ce.domain(validateArgumentCount(ce, canonical(ops), 1)[0]),
             },
         },
         Evaluate: {
@@ -23122,7 +23350,7 @@ const CORE_LIBRARY = [
             signature: {
                 domain: ['Function', 'Anything', 'Anything'],
                 codomain: (_ce, args) => args[0].domain,
-                canonical: (ce, ops) => ce._fn('Evaluate', validateArgumentCount(ce, ops.map((x) => x.canonical), 1)),
+                canonical: (ce, ops) => ce._fn('Evaluate', validateArgumentCount(ce, canonical(ops), 1)),
                 evaluate: (_ce, ops) => ops[0].evaluate(),
             },
         },
@@ -23351,8 +23579,7 @@ const CORE_LIBRARY = [
                     const op1 = ops[0];
                     const val = asFloat(op1) ?? NaN;
                     if (Number.isNaN(val) || !Number.isInteger(val)) {
-                        ce.signal(ce._fn('IntegerString', ops), `Expected first argument as an integer. Got \\(${op1.latex}$\\)`);
-                        return undefined;
+                        return ce.error(['incompatible-domain', 'Integer', op1.domain], op1);
                     }
                     const op2 = ops[1];
                     if (op2.isNothing) {
@@ -23364,14 +23591,11 @@ const CORE_LIBRARY = [
                         return ce.string(Math.abs(Math.round(asFloat(op1) ?? NaN)).toString());
                     }
                     if (asSmallInteger(op2) === null) {
-                        ce.signal(ce._fn('IntegerString', ops), `Expected \`base\` as an integer between 2 and 36. Got \\(${op2.latex}$\\)`);
-                        return undefined;
+                        return ce.error(['incompatible-domain', 'Integer', op2.domain], op2);
                     }
                     const base = asSmallInteger(op2);
-                    if (base < 2 || base > 36) {
-                        ce.signal(ce._fn('IntegerString', ops), `Expected \`base\` as an integer between 2 and 36. Got ${base}`);
-                        return undefined;
-                    }
+                    if (base < 2 || base > 36)
+                        return ce.error(['out-of-range', 2, 36, base], op2);
                     return ce.string(Math.abs(val).toString(base));
                 },
             },
@@ -23455,6 +23679,14 @@ const CORE_LIBRARY = [
             },
         },
     },
+    {
+        RandomExpression: {
+            signature: {
+                domain: 'Function',
+                evaluate: (ce, _ops) => ce.box(randomExpression()),
+            },
+        },
+    },
 ];
 // xcas/gias https://www-fourier.ujf-grenoble.fr/~parisse/giac/doc/en/cascmd_en/cascmd_en.html
 // https://www.haskell.org/onlinereport/haskell2010/haskellch9.html#x16-1720009.1
@@ -23795,9 +24027,7 @@ const RELOP_LIBRARY = {
         signature: {
             domain: 'RelationalOperator',
             canonical: (ce, ops) => {
-                ops =
-                    flattenOps(flattenSequence(ops).map((x) => x.canonical), 'Equal') ?? ops;
-                return ce._fn('Equal', ops);
+                return ce._fn('Equal', flattenOps(canonical(flattenSequence(ops)), 'Equal'));
             },
             evaluate: (ce, ops) => {
                 if (ops.length < 2)
@@ -23843,11 +24073,7 @@ const RELOP_LIBRARY = {
         complexity: 11000,
         signature: {
             domain: 'RelationalOperator',
-            canonical: (ce, ops) => {
-                ops =
-                    flattenOps(flattenSequence(ops).map((x) => x.canonical), 'Less') ?? ops;
-                return ce._fn('Less', ops);
-            },
+            canonical: (ce, ops) => ce._fn('Less', flattenOps(canonical(flattenSequence(ops)), 'Less')),
             evaluate: (ce, ops) => {
                 if (ops.length < 2)
                     return ce.symbol('True');
@@ -24085,7 +24311,7 @@ const SETS_LIBRARY = {
         signature: {
             domain: 'Predicate',
             canonical: (ce, args) => {
-                args = validateArgumentCount(ce, flattenSequence(args).map((x) => x.canonical), 2);
+                args = validateArgumentCount(ce, flattenSequence(canonical(args)), 2);
                 if (args.length === 2 && isDomain(args[1]))
                     return ce._fn('Element', [args[0], ce.domain(args[1])]);
                 return ce._fn('Element', args);
@@ -24299,13 +24525,15 @@ const TRIGONOMETRY_LIBRARY = [
             signature: {
                 domain: ['Function', 'Number', 'Number'],
                 canonical: (ce, ops) => {
-                    ops = validateArgumentCount(ce, flattenSequence(ops), 1);
+                    ops = validateArguments(ce, flattenSequence(canonical(ops)), [
+                        'Number',
+                    ]);
                     if (ops.length !== 1)
                         return ce.box(['Degrees', ops]);
-                    const arg = validateArgument(ce, ops[0].canonical, 'Number');
+                    const arg = ops[0];
                     if (arg.numericValue === null || !arg.isValid)
                         return ce.box(['Degrees', arg]);
-                    return ce.mul([arg, ce.box(['Divide', 'Pi', 180])]);
+                    return ce.div(ce.mul([arg, ce.symbol('Pi')]), ce.number(180));
                 },
                 evaluate: (ce, ops) => ce.mul([ops[0], ce.box(['Divide', 'Pi', 180])]),
             },
@@ -24664,7 +24892,7 @@ const TRIGONOMETRY_LIBRARY = [
             signature: {
                 domain: ['Function', 'Function', 'Function'],
                 canonical: (ce, ops) => {
-                    ops = validateArgumentCount(ce, flattenSequence(ops), 1).map((x) => x.canonical);
+                    ops = validateArgumentCount(ce, flattenSequence(canonical(ops)), 1);
                     return (processInverseFunction(ce, ops) ?? ce._fn('InverseFunction', ops));
                 },
                 simplify: (ce, ops) => processInverseFunction(ce, ops),
@@ -24898,7 +25126,7 @@ function constructibleValues(ce, head, x) {
     [sign, head] = TRIG_IDENTITIES[head]?.[quadrant] ?? [1, head];
     sign = sign * identitySign;
     for (const [[n, d], result] of specialValues) {
-        if (ce.chop(theta - (Math.PI * n) / d) === 0) {
+        if (result[head] && ce.chop(theta - (Math.PI * n) / d) === 0) {
             // Cos and Sec are even functions, the others are odd
             return sign < 0 ? canonicalNegate(result[head]) : result[head];
         }
@@ -25922,12 +26150,11 @@ function setCurrentContextSymbolTable(engine, table) {
             if (engine.strict && entry.wikidata) {
                 for (const [_, d] of idTable) {
                     if (d.wikidata === entry.wikidata)
-                        throw new Error(`Duplicate entry with wikidata "${entry.wikidata}": "${name}" and "${d.name}"`);
+                        throw new Error(`Duplicate entries with wikidata "${entry.wikidata}": "${name}" and "${d.name}"`);
                 }
             }
-            if (idTable.has(name)) {
-                throw new Error(`Duplicate symbol definition "${name}":\n${JSON.stringify(idTable.get(name))}\n${JSON.stringify(entry)}`);
-            }
+            if (idTable.has(name))
+                throw new Error(`Duplicate symbol definition "${name}"`);
             idTable.set(name, def);
         }
         else {
@@ -25977,7 +26204,7 @@ function setCurrentContextSymbolTable(engine, table) {
  * ```
  */
 function numericCostFunction(n) {
-    if (Number.isInteger(n)) {
+    if (Number.isInteger(n) && n !== 0) {
         return Math.floor(Math.log2(Math.abs(n)) / Math.log2(10)) + (n > 0 ? 1 : 2);
     }
     return 2;
@@ -26001,8 +26228,8 @@ function costFunction(expr) {
             if (isMachineRational(num))
                 return numericCostFunction(num[0]) + numericCostFunction(num[1]) + 1;
             else
-                return (numericCostFunction(num[0].toNumber()) +
-                    numericCostFunction(num[1].toNumber()) +
+                return (numericCostFunction(Number(num[0])) +
+                    numericCostFunction(Number(num[1])) +
                     1);
         }
         if (num instanceof Complex)
@@ -26011,8 +26238,24 @@ function costFunction(expr) {
             return 2;
     }
     const head = expr.head;
-    return ((typeof head === 'string' ? 1 : costFunction(head)) +
-        (expr.ops?.reduce((acc, x) => acc + costFunction(x), 0) ?? 0));
+    let headCost = 2;
+    if (typeof head === 'string') {
+        if (['Add', 'Divide'].includes(head))
+            headCost = 3;
+        else if (['Subtract', 'Negate'].includes(head))
+            headCost = 4;
+        else if (['Square', 'Sqrt', 'Multiply', 'Root'].includes(head))
+            headCost = 5;
+        else if (['Power'].includes(head))
+            headCost = 6;
+        else if (['Ln', 'Exp', 'Log'].includes(head))
+            headCost = 7;
+        else
+            headCost = 8;
+    }
+    else
+        headCost = costFunction(head);
+    return (headCost + (expr.ops?.reduce((acc, x) => acc + costFunction(x), 0) ?? 0));
 }
 const DEFAULT_COST_FUNCTION = costFunction;
 
@@ -26468,10 +26711,16 @@ class BoxedSymbol extends AbstractBoxedExpression {
     }
     /** A free variable either has no definition, or it has a definition, but no value */
     get isFree() {
-        return !this.symbolDefinition?.value;
+        // Don't use `.symbolDefinition` as this has a side effect of creating
+        // a def, which is not desirable whn we're just doing a test.
+        const def = this._def ?? this.engine.lookupSymbol(this._name, this._wikidata);
+        return !isSymbolDefinition(def) || def.value === undefined;
     }
     get isConstant() {
-        return this.symbolDefinition?.constant ?? false;
+        // Don't use `.symbolDefinition` as this has a side effect of creating
+        // a def, which is not desirable whn we're just doing a test.
+        const def = this._def ?? this.engine.lookupSymbol(this._name, this._wikidata);
+        return !isSymbolDefinition(def) || def.constant;
     }
     get isCanonical() {
         return this._scope !== null;
@@ -27051,7 +27300,7 @@ class ComputeEngine {
             shorthands: ['function', 'symbol', 'string', 'dictionary', 'number'],
             metadata: [],
             precision: 'max',
-            repeatingDecimals: true,
+            repeatingDecimals: false,
         };
         this._stats = {
             highwaterMark: 0,
@@ -27082,20 +27331,10 @@ class ComputeEngine {
         //
         this.context = {
             assumptions: new ExpressionMap(),
-            warn: (sigs) => {
-                for (const sig of sigs) {
-                    if (typeof sig.message === 'string') {
-                        console.warn(sig.message);
-                    }
-                    else {
-                        console.warn(...sig.message);
-                    }
-                }
-            },
             timeLimit: 2.0,
             memoryLimit: 1.0,
             recursionLimit: 1024,
-            // iterationLimit:    no iteration limit
+            iterationLimit: Number.POSITIVE_INFINITY,
         };
         const tables = options?.ids ?? ComputeEngine.getStandardLibrary();
         for (const table of tables)
@@ -27361,6 +27600,8 @@ class ComputeEngine {
     }
     /** @internal */
     bignum(a) {
+        if (typeof a === 'bigint')
+            return new this._bignum(a.toString());
         return new this._bignum(a);
     }
     /** @internal */
@@ -27508,6 +27749,10 @@ class ComputeEngine {
         if (this.context === null)
             throw Error('No parent scope available');
         this.context = {
+            timeLimit: this.context.timeLimit,
+            memoryLimit: this.context.memoryLimit,
+            recursionLimit: this.context.recursionLimit,
+            iterationLimit: this.context.iterationLimit,
             ...(scope ?? {}),
             parentScope: this.context,
             // We always copy the current assumptions in the new scope.
@@ -27535,29 +27780,6 @@ class ComputeEngine {
         if (!this.context)
             throw Error('No scope available');
         const parentScope = this.context?.parentScope;
-        // If there are some warnings, handle them
-        if (this.context.warnings) {
-            const warnings = [...this.context.warnings];
-            this.context.warnings = [];
-            if (this.context.warn) {
-                this.context.warn(warnings);
-            }
-        }
-        // If there are some unhandled warnings, or warnings signaled during the
-        // warning handler, propagate them.
-        if (parentScope &&
-            this.context.warnings &&
-            this.context.warnings.length > 0) {
-            if (!parentScope.warnings) {
-                parentScope.warnings = [...this.context.warnings];
-            }
-            else {
-                parentScope.warnings = [
-                    ...parentScope.warnings,
-                    ...this.context.warnings,
-                ];
-            }
-        }
         this.context = parentScope ?? null;
         console.assert(this.context !== null);
     }
@@ -27571,6 +27793,7 @@ class ComputeEngine {
                     if (def)
                         def.value = idk ?? undefined;
                     else if (idk !== undefined && idk !== null) {
+                        // Unknown identifier, define a new one
                         const val = this.box(idk);
                         if (val.domain.isNumeric)
                             this.defineSymbol(k, { value: val, domain: 'Number' });
@@ -27610,10 +27833,12 @@ class ComputeEngine {
         for (const k of Object.keys(identifiers)) {
             if (k !== 'Nothing') {
                 const def = identifiers[k];
-                if ('value' in def || ('domain' in def && def.domain !== 'Function'))
+                if (isSymbolDefinition$1(def))
                     this.defineSymbol(k, def);
-                else
+                else if (isFunctionDefinition$1(def))
                     this.defineFunction(k, def);
+                else
+                    this.set({ [k]: identifiers[k] });
             }
         }
     }
@@ -27649,31 +27874,14 @@ class ComputeEngine {
             throw new Error('timeout');
         }
     }
-    assert(condition, expr, msg, code) {
-        if (!condition)
-            this.signal(expr, msg, code);
-    }
-    signal(arg1, msg, code) {
-        let subject = '';
-        let message = '';
-        // @todo: store the warnings
-        if (typeof arg1 === 'object' && 'message' in arg1) {
-            code = arg1.message;
-        }
-        else {
-            subject = arg1.latex;
-            message = msg ?? '';
-        }
-        const codeString = code === undefined
-            ? ''
-            : typeof code === 'string'
-                ? `[${code}]`
-                : Array.isArray(code)
-                    ? '[' + code.map((x) => x.toString()).join(', ') + ']'
-                    : '';
-        console.error(`${subject}: ${message ?? ''} ${codeString}`);
-        return;
-    }
+    // assert(
+    //   condition: boolean,
+    //   expr: BoxedExpression,
+    //   msg: string,
+    //   code?: SignalMessage
+    // ) {
+    //   if (!condition) this.signal(expr, msg, code);
+    // }
     /** @internal */
     cache(cacheName, build, purge) {
         if (this._cache[cacheName] === undefined) {
@@ -27689,6 +27897,12 @@ class ComputeEngine {
     box(expr, options) {
         return box(this, expr, options);
     }
+    canonical(xs) {
+        if (!xs.every((x) => x instanceof AbstractBoxedExpression))
+            return xs.map((x) => this.box(x));
+        const bxs = xs;
+        return bxs.every((x) => x.isCanonical) ? bxs : bxs.map((x) => x.canonical);
+    }
     fn(head, ops, metadata) {
         return boxFunction(this, head, ops, { metadata, canonical: true });
     }
@@ -27731,29 +27945,27 @@ class ComputeEngine {
     }
     add(ops, metadata) {
         // Short path. Note that are arguments are **not** validated.
-        // ops = flattenSequence(ops);
-        const result = canonicalAdd(this, ops);
+        const result = canonicalAdd(this, flattenOps(flattenSequence(ops), 'Add'));
         if (metadata?.latex !== undefined)
             result.latex = metadata.latex;
         if (metadata?.wikidata !== undefined)
             result.wikidata = metadata.wikidata;
         return result;
     }
-    negate(expr, metadata) {
+    neg(expr, metadata) {
         // Short path. Note that are arguments are **not** validated.
         return canonicalNegate(expr, metadata);
     }
     mul(ops, metadata) {
         // Short path. Note that are arguments are **not** validated.
-        ops = flattenSequence(ops);
-        const result = canonicalMultiply(this, ops);
+        const result = canonicalMultiply(this, flattenOps(flattenSequence(ops), ' Multiply'));
         if (metadata?.latex !== undefined)
             result.latex = metadata.latex;
         if (metadata?.wikidata !== undefined)
             result.wikidata = metadata.wikidata;
         return result;
     }
-    divide(num, denom, metadata) {
+    div(num, denom, metadata) {
         // Short path. Note that are arguments are **not** validated.
         const result = canonicalDivide(this, num, denom);
         if (metadata?.latex !== undefined)
@@ -27763,11 +27975,11 @@ class ComputeEngine {
         return result;
     }
     sqrt(base, metadata) {
-        return this.power(base, [1, 2], metadata);
+        return canonicalPower(this, base, this._HALF, metadata);
     }
-    power(base, exponent, metadata) {
+    pow(base, exponent, metadata) {
         // Short path. Note that are arguments are **not** validated.
-        let e = null;
+        // The logic here handles the cases where the exponent is a number or Rational
         if (exponent instanceof AbstractBoxedExpression) {
             const num = exponent.numericValue;
             if (num !== null) {
@@ -27777,13 +27989,15 @@ class ComputeEngine {
                     exponent = num;
             }
         }
+        let e = null;
         if (typeof exponent === 'number')
             e = exponent;
         else if (isRational(exponent)) {
+            // Is the denominator 1?
             if (isMachineRational(exponent) && exponent[1] === 1)
                 e = exponent[0];
-            if (isBigRational(exponent) && exponent[1].equals(1))
-                e = exponent[0].toNumber();
+            else if (isBigRational(exponent) && exponent[1] === BigInt(1))
+                e = Number(exponent[0]);
         }
         // x^1
         if (e === 1)
@@ -27793,18 +28007,40 @@ class ComputeEngine {
         if (e === -1 && r !== null) {
             if (typeof r === 'number' && Number.isInteger(r))
                 return this.number([1, r]);
-            if (r instanceof Decimal && r.isInteger())
-                return this.number([base.engine._BIGNUM_ONE, r]);
-            if (isRational(r))
-                return this.number(isBigRational(r) ? [r[1], r[0]] : [r[1], r[0]]);
+            else if (r instanceof Decimal && r.isInteger())
+                return this.number([BigInt(1), bigint(r)]);
+            else if (isRational(r))
+                return this.number([r[1], r[0]]);
         }
         if (typeof exponent === 'number' || isRational(exponent))
             exponent = this.number(exponent);
-        return (canonicalPower(this, base, exponent, metadata) ??
-            this._fn('Power', [base, exponent], metadata));
+        return canonicalPower(this, base, exponent, metadata);
     }
-    inverse(expr, metadata) {
+    inv(expr, metadata) {
         // Short path. Note that are arguments are **not** validated.
+        if (expr.isOne)
+            return this._ONE;
+        if (expr.isNegativeOne)
+            return this._NEGATIVE_ONE;
+        if (expr.isInfinity)
+            return this._ZERO;
+        const n = expr.numericValue;
+        if (n !== null) {
+            if (isRational(n))
+                return this.number(inverse(n), { metadata });
+            if (typeof n === 'number' && Number.isInteger(n))
+                return this.number([1, n], { metadata });
+            if (n instanceof Decimal && n.isInteger())
+                return this.number([BigInt(1), bigint(n)], { metadata });
+            return this._fn('Divide', [this._ONE, expr], metadata);
+        }
+        if (expr.head === 'Sqrt')
+            return this._fn('Sqrt', [this.inv(expr.op1)], metadata);
+        if (expr.head === 'Divide')
+            return this._fn('Divide', [expr[1], expr[0]], metadata);
+        if (expr.head === 'Rational')
+            return this.number([expr[1], expr[0]], { metadata });
+        // Inverse(expr) -> expr^{-1}
         let e = this._NEGATIVE_ONE;
         if (expr.head === 'Power') {
             // Inverse(x^{-1}) -> x
@@ -27814,21 +28050,20 @@ class ComputeEngine {
             e = canonicalNegate(expr.op2);
             expr = expr.op1;
         }
-        // Inverse(expr) -> expr^{-1}
-        // Will take care of literals, i.e. Inverse(n/d) -> d/n
-        return (canonicalPower(this, expr, e, metadata) ??
-            this._fn('Power', [expr, e], metadata));
+        if (e.isNegativeOne)
+            return this._fn('Divide', [this._ONE, expr], metadata);
+        return this._fn('Power', [expr, e], metadata);
     }
     pair(first, second, metadata) {
         // Short path
-        return new BoxedFunction(this, 'Tuple', [first.canonical, second.canonical], {
+        return new BoxedFunction(this, 'Tuple', [first, second], {
             metadata,
             canonical: true,
         });
     }
     tuple(elements, metadata) {
         // Short path
-        return new BoxedFunction(this, 'Tuple', elements.map((x) => x.canonical), {
+        return new BoxedFunction(this, 'Tuple', canonical(elements), {
             metadata,
             canonical: true,
         });
@@ -27905,24 +28140,36 @@ class ComputeEngine {
         //
         // Is this number eligible to be a cached number expression?
         //
-        if (options.metadata === undefined && typeof value === 'number') {
-            const n = value;
-            if (n === 1)
-                return this._ONE;
-            if (n === 0)
-                return this._ZERO;
-            if (n === -1)
-                return this._NEGATIVE_ONE;
-            if (Number.isInteger(n) && this._commonNumbers[n] !== undefined) {
-                if (this._commonNumbers[n] === null)
-                    this._commonNumbers[n] = boxNumber(this, value) ?? this._NAN;
-                return this._commonNumbers[n];
+        if (options.metadata === undefined) {
+            if (typeof value === 'bigint') {
+                if (value === BigInt(1))
+                    return this._ONE;
+                if (value === BigInt(0))
+                    return this._ZERO;
+                if (value === BigInt(-1))
+                    return this._NEGATIVE_ONE;
+            }
+            if (typeof value === 'number') {
+                const n = value;
+                if (n === 1)
+                    return this._ONE;
+                if (n === 0)
+                    return this._ZERO;
+                if (n === -1)
+                    return this._NEGATIVE_ONE;
+                if (Number.isInteger(n) && this._commonNumbers[n] !== undefined) {
+                    if (this._commonNumbers[n] === null)
+                        this._commonNumbers[n] = boxNumber(this, value) ?? this._NAN;
+                    return this._commonNumbers[n];
+                }
+                if (Number.isNaN(n))
+                    return this._NAN;
+                if (!Number.isFinite(n))
+                    return n < 0 ? this._NEGATIVE_INFINITY : this._POSITIVE_INFINITY;
             }
-            if (Number.isNaN(n))
-                return this._NAN;
-            if (!Number.isFinite(n))
-                return n < 0 ? this._NEGATIVE_INFINITY : this._POSITIVE_INFINITY;
         }
+        if (typeof value === 'bigint')
+            value = this.bignum(value);
         return boxNumber(this, value, options) ?? this._NAN;
     }
     rules(rules) {
@@ -28094,8 +28341,7 @@ class ComputeEngine {
             // it in a parent scope. However, when the current scope exits,
             // any previous assumptions about the symbol will be restored).
             for (const [assumption, _val] of this.assumptions) {
-                const vars = getVars(assumption);
-                if (vars.includes(symbol))
+                if (assumption.symbols.includes(symbol))
                     this.assumptions.delete(assumption);
             }
         }
@@ -28103,6 +28349,10 @@ class ComputeEngine {
 }
 
 // This file is the root of the `compute-engine` package
-const version = '0.11.0';
+const version = '0.12.1';
+globalThis[Symbol.for('io.cortexjs.compute-engine')] = {
+    ComputeEngine: ComputeEngine.constructor,
+    version: '0.12.1',
+};
 
-export { ComputeEngine, getVars, isEnvironmentEntry, isFunctionEntry, isInfixEntry, isMatchfixEntry, isPostfixEntry, isPrefixEntry, isSymbolEntry, version };
+export { ComputeEngine, isEnvironmentEntry, isFunctionEntry, isInfixEntry, isMatchfixEntry, isPostfixEntry, isPrefixEntry, isSymbolEntry, version };