@cortex-js/compute-engine 0.53.1 → 0.54.0

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.53.1 */
+/** Compute Engine 0.54.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -12351,6 +12351,18 @@ var ComputeEngine = (() => {
   function _setExpandForIs(fn) {
     _expandForIs = fn;
   }
+  var _getPolynomialCoefficients;
+  function _setGetPolynomialCoefficients(fn) {
+    _getPolynomialCoefficients = fn;
+  }
+  var _getPolynomialDegree;
+  function _setGetPolynomialDegree(fn) {
+    _getPolynomialDegree = fn;
+  }
+  var _findUnivariateRoots;
+  function _setFindUnivariateRoots(fn) {
+    _findUnivariateRoots = fn;
+  }
   var EXPANDABLE_OPS = ["Multiply", "Power", "Negate", "Divide"];
   function _couldBenefitFromExpand(a, b) {
     if (a.has(EXPANDABLE_OPS)) return true;
@@ -12666,6 +12678,34 @@ var ComputeEngine = (() => {
     factors() {
       return [this];
     }
+    polynomialCoefficients(variable) {
+      let vars;
+      if (variable === void 0) {
+        const unknowns = this.unknowns;
+        if (unknowns.length !== 1) return void 0;
+        vars = [unknowns[0]];
+      } else if (typeof variable === "string") {
+        vars = [variable];
+      } else {
+        if (variable.length === 0) return void 0;
+        vars = variable;
+      }
+      for (const v of vars) {
+        if (_getPolynomialDegree(this, v) < 0) return void 0;
+      }
+      const coeffs = _getPolynomialCoefficients(this, vars[0]);
+      if (coeffs === null) return void 0;
+      return coeffs.reverse();
+    }
+    polynomialRoots(variable) {
+      if (variable === void 0) {
+        const unknowns = this.unknowns;
+        if (unknowns.length !== 1) return void 0;
+        variable = unknowns[0];
+      }
+      if (_getPolynomialDegree(this, variable) < 0) return void 0;
+      return _findUnivariateRoots(this, variable);
+    }
     is(other, tolerance) {
       if (this.isSame(other)) return true;
       if (_expandForIs && _couldBenefitFromExpand(this, other)) {
@@ -16125,10 +16165,14 @@ ${lines.join("\n")}`;
     return expr.operator === "Sqrt" || expr.operator === "Power" && expr.op2.im === 0 && expr.op2.re === 0.5 || expr.operator === "Root" && expr.op2.im === 0 && expr.op2.re === 2;
   }
   function asRadical(expr) {
-    if (isSqrt(expr) && isFunction2(expr)) return asRational(expr.op1) ?? null;
+    if (isSqrt(expr) && isFunction2(expr)) {
+      const r = asRational(expr.op1);
+      if (r === void 0 || r[0] < 0 || r[1] < 0) return null;
+      return r;
+    }
     if (isFunction2(expr, "Divide") && expr.op1.isSame(1) && isSqrt(expr.op2)) {
       const n = expr.op2.re;
-      if (!Number.isInteger(n)) return null;
+      if (!Number.isInteger(n) || n <= 0) return null;
       return [1, n];
     }
     return null;
@@ -24009,7 +24053,9 @@ ${lines.join("\n")}`;
           if (n === null) return void 0;
           const ce = x.engine;
           if (bignumPreferred(ce))
-            return ce.number(run(factorial23(ce, ce.bignum(n)), ce._timeRemaining));
+            return ce.number(
+              run(factorial23(ce, ce.bignum(n)), ce._timeRemaining)
+            );
           return ce.number(factorial22(n));
         }
       },
@@ -26410,6 +26456,268 @@ ${e.message}
     return expand2(result);
   }
 
+  // src/compute-engine/boxed-expression/polynomials.ts
+  function polynomialDegree(expr, variable) {
+    if (isNumber(expr)) return 0;
+    if (isSymbol2(expr)) {
+      if (expr.symbol === variable) return 1;
+      return 0;
+    }
+    if (!isFunction2(expr)) {
+      if (expr.has(variable)) return -1;
+      return 0;
+    }
+    const op = expr.operator;
+    if (op === "Negate") return polynomialDegree(expr.op1, variable);
+    if (op === "Add" || op === "Subtract") {
+      let maxDeg = 0;
+      for (const arg of expr.ops) {
+        const deg = polynomialDegree(arg, variable);
+        if (deg < 0) return -1;
+        maxDeg = Math.max(maxDeg, deg);
+      }
+      return maxDeg;
+    }
+    if (op === "Multiply") {
+      let totalDeg = 0;
+      for (const arg of expr.ops) {
+        const deg = polynomialDegree(arg, variable);
+        if (deg < 0) return -1;
+        totalDeg += deg;
+      }
+      return totalDeg;
+    }
+    if (op === "Power") {
+      const baseDeg = polynomialDegree(expr.op1, variable);
+      if (baseDeg < 0) return -1;
+      if (baseDeg === 0) {
+        if (expr.op2.has(variable)) return -1;
+        return 0;
+      }
+      const exp3 = asSmallInteger(expr.op2);
+      if (exp3 === null || exp3 < 0) return -1;
+      return baseDeg * exp3;
+    }
+    if (expr.has(variable)) return -1;
+    return 0;
+  }
+  function getPolynomialCoefficients(expr, variable) {
+    const ce = expr.engine;
+    const degree = polynomialDegree(expr, variable);
+    if (degree < 0) return null;
+    const coeffs = new Array(degree + 1).fill(ce.Zero);
+    const expanded = expand2(expr);
+    const addCoefficient = (coef, deg) => {
+      if (deg > degree) return false;
+      coeffs[deg] = coeffs[deg].add(coef);
+      return true;
+    };
+    const processTerm = (term) => {
+      const termDeg = polynomialDegree(term, variable);
+      if (termDeg < 0) return false;
+      if (termDeg === 0) {
+        return addCoefficient(term, 0);
+      }
+      if (isSymbol2(term, variable)) {
+        return addCoefficient(ce.One, 1);
+      }
+      if (isFunction2(term, "Negate")) {
+        const innerDeg = polynomialDegree(term.op1, variable);
+        if (innerDeg === 0) {
+          return addCoefficient(term, 0);
+        }
+        const innerCoeffs = getPolynomialCoefficients(term.op1, variable);
+        if (!innerCoeffs) return false;
+        for (let i = 0; i < innerCoeffs.length; i++) {
+          if (!innerCoeffs[i].isSame(0)) {
+            addCoefficient(innerCoeffs[i].neg(), i);
+          }
+        }
+        return true;
+      }
+      if (isFunction2(term, "Power")) {
+        if (isSymbol2(term.op1, variable)) {
+          const exp3 = asSmallInteger(term.op2);
+          if (exp3 !== null && exp3 >= 0) {
+            return addCoefficient(ce.One, exp3);
+          }
+        }
+        if (!term.op1.has(variable)) {
+          return addCoefficient(term, 0);
+        }
+        return false;
+      }
+      if (isFunction2(term, "Multiply")) {
+        const factors = term.ops;
+        let coef = ce.One;
+        let varDeg = 0;
+        for (const factor3 of factors) {
+          if (!factor3.has(variable)) {
+            coef = coef.mul(factor3);
+          } else if (isSymbol2(factor3, variable)) {
+            varDeg += 1;
+          } else if (isFunction2(factor3, "Power") && isSymbol2(factor3.op1, variable)) {
+            const exp3 = asSmallInteger(factor3.op2);
+            if (exp3 !== null && exp3 >= 0) {
+              varDeg += exp3;
+            } else {
+              return false;
+            }
+          } else {
+            return false;
+          }
+        }
+        return addCoefficient(coef, varDeg);
+      }
+      return false;
+    };
+    if (isFunction2(expanded, "Add")) {
+      for (const term of expanded.ops) {
+        if (!processTerm(term)) return null;
+      }
+    } else {
+      if (!processTerm(expanded)) return null;
+    }
+    return coeffs;
+  }
+  function fromCoefficients(coeffs, variable) {
+    if (coeffs.length === 0) return coeffs[0]?.engine.Zero ?? null;
+    const ce = coeffs[0].engine;
+    const x = ce.symbol(variable);
+    const terms = [];
+    for (let i = 0; i < coeffs.length; i++) {
+      const coef = coeffs[i];
+      if (coef.isSame(0)) continue;
+      if (i === 0) {
+        terms.push(coef);
+      } else if (i === 1) {
+        if (coef.isSame(1)) {
+          terms.push(x);
+        } else if (coef.isSame(-1)) {
+          terms.push(x.neg());
+        } else {
+          terms.push(coef.mul(x));
+        }
+      } else {
+        const xPow = ce.box(["Power", variable, i]);
+        if (coef.isSame(1)) {
+          terms.push(xPow);
+        } else if (coef.isSame(-1)) {
+          terms.push(xPow.neg());
+        } else {
+          terms.push(coef.mul(xPow));
+        }
+      }
+    }
+    if (terms.length === 0) return ce.Zero;
+    if (terms.length === 1) return terms[0];
+    return add3(...terms);
+  }
+  function polynomialDivide(dividend, divisor, variable) {
+    const ce = dividend.engine;
+    const dividendCoeffs = getPolynomialCoefficients(dividend, variable);
+    const divisorCoeffs = getPolynomialCoefficients(divisor, variable);
+    if (!dividendCoeffs || !divisorCoeffs) return null;
+    if (divisorCoeffs.every((c) => c.isSame(0))) return null;
+    const actualDegree = (coeffs) => {
+      for (let i = coeffs.length - 1; i >= 0; i--) {
+        if (!coeffs[i].isSame(0)) return i;
+      }
+      return -1;
+    };
+    const dividendDeg = actualDegree(dividendCoeffs);
+    const divisorDeg = actualDegree(divisorCoeffs);
+    if (divisorDeg < 0) return null;
+    if (dividendDeg < 0) {
+      return [ce.Zero, ce.Zero];
+    }
+    if (dividendDeg < divisorDeg) {
+      return [ce.Zero, dividend];
+    }
+    const remainder2 = dividendCoeffs.map((c) => c);
+    const quotientCoeffs = new Array(
+      dividendDeg - divisorDeg + 1
+    ).fill(ce.Zero);
+    const leadingDivisor = divisorCoeffs[divisorDeg];
+    for (let i = dividendDeg; i >= divisorDeg; i--) {
+      if (remainder2[i].isSame(0)) continue;
+      const quotientCoef = remainder2[i].div(leadingDivisor);
+      quotientCoeffs[i - divisorDeg] = quotientCoef;
+      for (let j = 0; j <= divisorDeg; j++) {
+        const product = quotientCoef.mul(divisorCoeffs[j]);
+        remainder2[i - divisorDeg + j] = remainder2[i - divisorDeg + j].sub(product);
+      }
+    }
+    const quotient = fromCoefficients(quotientCoeffs, variable);
+    const remainderPoly = fromCoefficients(remainder2, variable);
+    return [quotient, remainderPoly];
+  }
+  function polynomialGCD(a, b, variable) {
+    const ce = a.engine;
+    const degA = polynomialDegree(a, variable);
+    const degB = polynomialDegree(b, variable);
+    if (degA < 0 || degB < 0) return ce.One;
+    const aCoeffs = getPolynomialCoefficients(a, variable);
+    const bCoeffs = getPolynomialCoefficients(b, variable);
+    if (!aCoeffs || aCoeffs.every((c) => c.isSame(0))) {
+      return makeMonic(b, variable);
+    }
+    if (!bCoeffs || bCoeffs.every((c) => c.isSame(0))) {
+      return makeMonic(a, variable);
+    }
+    let p = a;
+    let q = b;
+    while (true) {
+      const qCoeffs = getPolynomialCoefficients(q, variable);
+      if (!qCoeffs || qCoeffs.every((c) => c.isSame(0))) {
+        break;
+      }
+      const divResult = polynomialDivide(p, q, variable);
+      if (!divResult) {
+        return ce.One;
+      }
+      const [, remainder2] = divResult;
+      p = q;
+      q = remainder2;
+    }
+    return makeMonic(p, variable);
+  }
+  function makeMonic(poly, variable) {
+    const coeffs = getPolynomialCoefficients(poly, variable);
+    if (!coeffs) return poly;
+    let leadingCoef = null;
+    for (let i = coeffs.length - 1; i >= 0; i--) {
+      if (!coeffs[i].isSame(0)) {
+        leadingCoef = coeffs[i];
+        break;
+      }
+    }
+    if (!leadingCoef || leadingCoef.isSame(1)) return poly;
+    const monicCoeffs = coeffs.map((c) => c.div(leadingCoef));
+    return fromCoefficients(monicCoeffs, variable);
+  }
+  function cancelCommonFactors(expr, variable) {
+    if (!isFunction2(expr, "Divide")) return expr;
+    const numerator = expr.op1;
+    const denominator = expr.op2;
+    const numDeg = polynomialDegree(numerator, variable);
+    const denDeg = polynomialDegree(denominator, variable);
+    if (numDeg < 0 || denDeg < 0) return expr;
+    const gcd7 = polynomialGCD(numerator, denominator, variable);
+    const gcdDeg = polynomialDegree(gcd7, variable);
+    if (gcdDeg <= 0) return expr;
+    const numDivResult = polynomialDivide(numerator, gcd7, variable);
+    const denDivResult = polynomialDivide(denominator, gcd7, variable);
+    if (!numDivResult || !denDivResult) return expr;
+    const [newNumerator] = numDivResult;
+    const [newDenominator] = denDivResult;
+    const denCoeffs = getPolynomialCoefficients(newDenominator, variable);
+    if (denCoeffs && denCoeffs.length === 1 && denCoeffs[0].isSame(1)) {
+      return newNumerator;
+    }
+    return newNumerator.div(newDenominator);
+  }
+
   // src/compute-engine/boxed-expression/solve.ts
   function numericApproximation(value) {
     if (typeof value === "number") return value;
@@ -27233,6 +27541,13 @@ ${e.message}
           )
         );
       }
+      if (result.length === 0) {
+        const deg = polynomialDegree(originalExpr, x);
+        if (deg >= 3) {
+          const rationalRoots = findRationalRoots(originalExpr, x, ce);
+          if (rationalRoots.length > 0) result = rationalRoots;
+        }
+      }
     } finally {
       ce.popScope();
     }
@@ -27371,267 +27686,49 @@ ${e.message}
       return true;
     });
   }
-
-  // src/compute-engine/boxed-expression/polynomials.ts
-  function polynomialDegree(expr, variable) {
-    if (isNumber(expr)) return 0;
-    if (isSymbol2(expr)) {
-      if (expr.symbol === variable) return 1;
-      return 0;
-    }
-    if (!isFunction2(expr)) {
-      if (expr.has(variable)) return -1;
-      return 0;
-    }
-    const op = expr.operator;
-    if (op === "Negate") return polynomialDegree(expr.op1, variable);
-    if (op === "Add" || op === "Subtract") {
-      let maxDeg = 0;
-      for (const arg of expr.ops) {
-        const deg = polynomialDegree(arg, variable);
-        if (deg < 0) return -1;
-        maxDeg = Math.max(maxDeg, deg);
-      }
-      return maxDeg;
-    }
-    if (op === "Multiply") {
-      let totalDeg = 0;
-      for (const arg of expr.ops) {
-        const deg = polynomialDegree(arg, variable);
-        if (deg < 0) return -1;
-        totalDeg += deg;
-      }
-      return totalDeg;
-    }
-    if (op === "Power") {
-      const baseDeg = polynomialDegree(expr.op1, variable);
-      if (baseDeg < 0) return -1;
-      if (baseDeg === 0) {
-        if (expr.op2.has(variable)) return -1;
-        return 0;
-      }
-      const exp3 = asSmallInteger(expr.op2);
-      if (exp3 === null || exp3 < 0) return -1;
-      return baseDeg * exp3;
-    }
-    if (expr.has(variable)) return -1;
-    return 0;
-  }
-  function getPolynomialCoefficients(expr, variable) {
-    const ce = expr.engine;
-    const degree = polynomialDegree(expr, variable);
-    if (degree < 0) return null;
-    const coeffs = new Array(degree + 1).fill(ce.Zero);
-    const expanded = expand2(expr);
-    const addCoefficient = (coef, deg) => {
-      if (deg > degree) return false;
-      coeffs[deg] = coeffs[deg].add(coef);
-      return true;
-    };
-    const processTerm = (term) => {
-      const termDeg = polynomialDegree(term, variable);
-      if (termDeg < 0) return false;
-      if (termDeg === 0) {
-        return addCoefficient(term, 0);
-      }
-      if (isSymbol2(term, variable)) {
-        return addCoefficient(ce.One, 1);
-      }
-      if (isFunction2(term, "Negate")) {
-        const innerDeg = polynomialDegree(term.op1, variable);
-        if (innerDeg === 0) {
-          return addCoefficient(term, 0);
-        }
-        const innerCoeffs = getPolynomialCoefficients(term.op1, variable);
-        if (!innerCoeffs) return false;
-        for (let i = 0; i < innerCoeffs.length; i++) {
-          if (!innerCoeffs[i].isSame(0)) {
-            addCoefficient(innerCoeffs[i].neg(), i);
-          }
-        }
-        return true;
-      }
-      if (isFunction2(term, "Power")) {
-        if (isSymbol2(term.op1, variable)) {
-          const exp3 = asSmallInteger(term.op2);
-          if (exp3 !== null && exp3 >= 0) {
-            return addCoefficient(ce.One, exp3);
-          }
-        }
-        if (!term.op1.has(variable)) {
-          return addCoefficient(term, 0);
-        }
-        return false;
-      }
-      if (isFunction2(term, "Multiply")) {
-        const factors = term.ops;
-        let coef = ce.One;
-        let varDeg = 0;
-        for (const factor3 of factors) {
-          if (!factor3.has(variable)) {
-            coef = coef.mul(factor3);
-          } else if (isSymbol2(factor3, variable)) {
-            varDeg += 1;
-          } else if (isFunction2(factor3, "Power") && isSymbol2(factor3.op1, variable)) {
-            const exp3 = asSmallInteger(factor3.op2);
-            if (exp3 !== null && exp3 >= 0) {
-              varDeg += exp3;
-            } else {
-              return false;
-            }
-          } else {
-            return false;
-          }
+  function findRationalRoots(expr, variable, ce) {
+    const coeffs = getPolynomialCoefficients(expr, variable);
+    if (!coeffs) return [];
+    const degree = coeffs.length - 1;
+    if (degree < 1) return [];
+    const constantInt = asSmallInteger(coeffs[0]);
+    const leadingInt = asSmallInteger(coeffs[degree]);
+    if (leadingInt === null || constantInt === null) return [];
+    if (leadingInt === 0 || constantInt === 0) return [];
+    const divisors = (n) => {
+      n = Math.abs(n);
+      const result = [];
+      for (let i = 1; i * i <= n; i++) {
+        if (n % i === 0) {
+          result.push(i);
+          if (i !== n / i) result.push(n / i);
         }
-        return addCoefficient(coef, varDeg);
       }
-      return false;
+      return result;
     };
-    if (isFunction2(expanded, "Add")) {
-      for (const term of expanded.ops) {
-        if (!processTerm(term)) return null;
-      }
-    } else {
-      if (!processTerm(expanded)) return null;
-    }
-    return coeffs;
-  }
-  function fromCoefficients(coeffs, variable) {
-    if (coeffs.length === 0) return coeffs[0]?.engine.Zero ?? null;
-    const ce = coeffs[0].engine;
-    const x = ce.symbol(variable);
-    const terms = [];
-    for (let i = 0; i < coeffs.length; i++) {
-      const coef = coeffs[i];
-      if (coef.isSame(0)) continue;
-      if (i === 0) {
-        terms.push(coef);
-      } else if (i === 1) {
-        if (coef.isSame(1)) {
-          terms.push(x);
-        } else if (coef.isSame(-1)) {
-          terms.push(x.neg());
-        } else {
-          terms.push(coef.mul(x));
-        }
-      } else {
-        const xPow = ce.box(["Power", variable, i]);
-        if (coef.isSame(1)) {
-          terms.push(xPow);
-        } else if (coef.isSame(-1)) {
-          terms.push(xPow.neg());
-        } else {
-          terms.push(coef.mul(xPow));
+    const pDivisors = divisors(constantInt);
+    const qDivisors = divisors(leadingInt);
+    const candidates = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of pDivisors) {
+      for (const q of qDivisors) {
+        for (const sign3 of [1, -1]) {
+          const val = sign3 * p / q;
+          if (!seen.has(val)) {
+            seen.add(val);
+            candidates.push(val);
+          }
         }
       }
     }
-    if (terms.length === 0) return ce.Zero;
-    if (terms.length === 1) return terms[0];
-    return add3(...terms);
-  }
-  function polynomialDivide(dividend, divisor, variable) {
-    const ce = dividend.engine;
-    const dividendCoeffs = getPolynomialCoefficients(dividend, variable);
-    const divisorCoeffs = getPolynomialCoefficients(divisor, variable);
-    if (!dividendCoeffs || !divisorCoeffs) return null;
-    if (divisorCoeffs.every((c) => c.isSame(0))) return null;
-    const actualDegree = (coeffs) => {
-      for (let i = coeffs.length - 1; i >= 0; i--) {
-        if (!coeffs[i].isSame(0)) return i;
-      }
-      return -1;
-    };
-    const dividendDeg = actualDegree(dividendCoeffs);
-    const divisorDeg = actualDegree(divisorCoeffs);
-    if (divisorDeg < 0) return null;
-    if (dividendDeg < 0) {
-      return [ce.Zero, ce.Zero];
-    }
-    if (dividendDeg < divisorDeg) {
-      return [ce.Zero, dividend];
-    }
-    const remainder2 = dividendCoeffs.map((c) => c);
-    const quotientCoeffs = new Array(
-      dividendDeg - divisorDeg + 1
-    ).fill(ce.Zero);
-    const leadingDivisor = divisorCoeffs[divisorDeg];
-    for (let i = dividendDeg; i >= divisorDeg; i--) {
-      if (remainder2[i].isSame(0)) continue;
-      const quotientCoef = remainder2[i].div(leadingDivisor);
-      quotientCoeffs[i - divisorDeg] = quotientCoef;
-      for (let j = 0; j <= divisorDeg; j++) {
-        const product = quotientCoef.mul(divisorCoeffs[j]);
-        remainder2[i - divisorDeg + j] = remainder2[i - divisorDeg + j].sub(product);
-      }
-    }
-    const quotient = fromCoefficients(quotientCoeffs, variable);
-    const remainderPoly = fromCoefficients(remainder2, variable);
-    return [quotient, remainderPoly];
-  }
-  function polynomialGCD(a, b, variable) {
-    const ce = a.engine;
-    const degA = polynomialDegree(a, variable);
-    const degB = polynomialDegree(b, variable);
-    if (degA < 0 || degB < 0) return ce.One;
-    const aCoeffs = getPolynomialCoefficients(a, variable);
-    const bCoeffs = getPolynomialCoefficients(b, variable);
-    if (!aCoeffs || aCoeffs.every((c) => c.isSame(0))) {
-      return makeMonic(b, variable);
-    }
-    if (!bCoeffs || bCoeffs.every((c) => c.isSame(0))) {
-      return makeMonic(a, variable);
-    }
-    let p = a;
-    let q = b;
-    while (true) {
-      const qCoeffs = getPolynomialCoefficients(q, variable);
-      if (!qCoeffs || qCoeffs.every((c) => c.isSame(0))) {
-        break;
-      }
-      const divResult = polynomialDivide(p, q, variable);
-      if (!divResult) {
-        return ce.One;
-      }
-      const [, remainder2] = divResult;
-      p = q;
-      q = remainder2;
-    }
-    return makeMonic(p, variable);
-  }
-  function makeMonic(poly, variable) {
-    const coeffs = getPolynomialCoefficients(poly, variable);
-    if (!coeffs) return poly;
-    let leadingCoef = null;
-    for (let i = coeffs.length - 1; i >= 0; i--) {
-      if (!coeffs[i].isSame(0)) {
-        leadingCoef = coeffs[i];
-        break;
-      }
-    }
-    if (!leadingCoef || leadingCoef.isSame(1)) return poly;
-    const monicCoeffs = coeffs.map((c) => c.div(leadingCoef));
-    return fromCoefficients(monicCoeffs, variable);
-  }
-  function cancelCommonFactors(expr, variable) {
-    if (!isFunction2(expr, "Divide")) return expr;
-    const numerator = expr.op1;
-    const denominator = expr.op2;
-    const numDeg = polynomialDegree(numerator, variable);
-    const denDeg = polynomialDegree(denominator, variable);
-    if (numDeg < 0 || denDeg < 0) return expr;
-    const gcd6 = polynomialGCD(numerator, denominator, variable);
-    const gcdDeg = polynomialDegree(gcd6, variable);
-    if (gcdDeg <= 0) return expr;
-    const numDivResult = polynomialDivide(numerator, gcd6, variable);
-    const denDivResult = polynomialDivide(denominator, gcd6, variable);
-    if (!numDivResult || !denDivResult) return expr;
-    const [newNumerator] = numDivResult;
-    const [newDenominator] = denDivResult;
-    const denCoeffs = getPolynomialCoefficients(newDenominator, variable);
-    if (denCoeffs && denCoeffs.length === 1 && denCoeffs[0].isSame(1)) {
-      return newNumerator;
+    if (candidates.length > 100) return [];
+    const roots = [];
+    for (const candidate of candidates) {
+      const root2 = ce.number(candidate);
+      const value = expr.subs({ [variable]: root2 }).N();
+      if (value.isSame(0)) roots.push(root2);
     }
-    return newNumerator.div(newDenominator);
+    return roots;
   }
 
   // src/compute-engine/symbolic/antiderivative.ts
@@ -38275,7 +38372,107 @@ ${e.message}
       return ce.box(["Multiply", a.json, factor1.json, factor22.json]);
     }
   }
+  function factorByRationalRoots(expr, variable) {
+    const ce = expr.engine;
+    const coeffs = getPolynomialCoefficients(expr, variable);
+    if (!coeffs) return null;
+    const degree = coeffs.length - 1;
+    if (degree < 2) return null;
+    const leadingInt = asSmallInteger(coeffs[degree]);
+    const constantInt = asSmallInteger(coeffs[0]);
+    if (leadingInt === null || constantInt === null) return null;
+    if (leadingInt === 0 || constantInt === 0) return null;
+    const divisors = (n) => {
+      n = Math.abs(n);
+      const result = [];
+      for (let i = 1; i * i <= n; i++) {
+        if (n % i === 0) {
+          result.push(i);
+          if (i !== n / i) result.push(n / i);
+        }
+      }
+      return result;
+    };
+    const pDivisors = divisors(constantInt);
+    const qDivisors = divisors(leadingInt);
+    const candidates = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of pDivisors) {
+      for (const q of qDivisors) {
+        const pos = p / q;
+        const neg2 = -p / q;
+        if (!seen.has(pos)) {
+          seen.add(pos);
+          candidates.push([p, q]);
+        }
+        if (!seen.has(neg2)) {
+          seen.add(neg2);
+          candidates.push([-p, q]);
+        }
+      }
+    }
+    if (candidates.length > 100) return null;
+    const x = ce.symbol(variable);
+    const factors = [];
+    let remaining = expr;
+    for (const [p, q] of candidates) {
+      const remDeg2 = polynomialDegree(remaining, variable);
+      if (remDeg2 <= 0) break;
+      const root2 = q === 1 ? ce.number(p) : ce.number(p).div(ce.number(q));
+      const value = remaining.subs({ [variable]: root2 }).N();
+      if (!value.isSame(0)) continue;
+      const linearFactor = q === 1 ? x.sub(ce.number(p)) : ce.number(q).mul(x).sub(ce.number(p));
+      const divResult = polynomialDivide(remaining, linearFactor, variable);
+      if (!divResult) continue;
+      factors.push(linearFactor);
+      remaining = divResult[0];
+    }
+    if (factors.length === 0) return null;
+    const remDeg = polynomialDegree(remaining, variable);
+    if (remDeg === 2) {
+      const quadFactored = factorQuadratic(remaining, variable);
+      if (quadFactored !== null) remaining = quadFactored;
+    }
+    factors.push(remaining);
+    if (factors.length === 1) return factors[0];
+    return ce.box(["Multiply", ...factors.map((f) => f.json)]);
+  }
+  function extractContent(expr, variable) {
+    const ce = expr.engine;
+    const coeffs = getPolynomialCoefficients(expr, variable);
+    if (!coeffs) return null;
+    const intCoeffs = [];
+    for (const c of coeffs) {
+      const n = asSmallInteger(c);
+      if (n === null) return null;
+      intCoeffs.push(n);
+    }
+    const gcd7 = (a, b) => {
+      a = Math.abs(a);
+      b = Math.abs(b);
+      while (b) {
+        [a, b] = [b, a % b];
+      }
+      return a;
+    };
+    let content = 0;
+    for (const c of intCoeffs) {
+      if (c !== 0) content = gcd7(content, c);
+    }
+    if (content <= 1) return null;
+    const primitiveCoeffs = coeffs.map((c) => {
+      const n = asSmallInteger(c);
+      return ce.number(n / content);
+    });
+    const primitive = fromCoefficients(primitiveCoeffs, variable);
+    const factoredPrimitive = factorPolynomial(primitive, variable);
+    return ce.number(content).mul(factoredPrimitive);
+  }
   function factorPolynomial(expr, variable) {
+    if (variable !== void 0) {
+      const contentFactored = extractContent(expr, variable);
+      if (contentFactored !== null) return contentFactored;
+    }
     const perfectSquare = factorPerfectSquare(expr);
     if (perfectSquare !== null) return perfectSquare;
     const diffSquares = factorDifferenceOfSquares(expr);
@@ -38283,6 +38480,8 @@ ${e.message}
     if (variable !== void 0) {
       const quadratic = factorQuadratic(expr, variable);
       if (quadratic !== null) return quadratic;
+      const rationalRoot = factorByRationalRoots(expr, variable);
+      if (rationalRoot !== null) return rationalRoot;
     }
     return factor(expr);
   }
@@ -38328,6 +38527,257 @@ ${e.message}
     }
     return Product.from(together(expr)).asExpression();
   }
+  function collectFactors(expr, variable) {
+    const rawFactors = [];
+    collectFactorsRaw(expr, variable, rawFactors);
+    const merged = [];
+    for (const f of rawFactors) {
+      let found = false;
+      for (const m of merged) {
+        if (m.factor.isSame(f.factor)) {
+          m.multiplicity += f.multiplicity;
+          found = true;
+          break;
+        }
+      }
+      if (!found) merged.push({ ...f });
+    }
+    return merged;
+  }
+  function collectFactorsRaw(expr, variable, result) {
+    if (isFunction2(expr, "Multiply")) {
+      for (const op of expr.ops) {
+        collectFactorsRaw(op, variable, result);
+      }
+      return;
+    }
+    if (isFunction2(expr, "Power")) {
+      const base = expr.op1;
+      const exp3 = asSmallInteger(expr.op2);
+      if (exp3 !== null && exp3 > 0 && base.has(variable)) {
+        const deg3 = polynomialDegree(base, variable);
+        result.push({ factor: base, multiplicity: exp3, degree: deg3 });
+        return;
+      }
+      if (!expr.has(variable)) return;
+      const deg2 = polynomialDegree(expr, variable);
+      result.push({ factor: expr, multiplicity: 1, degree: deg2 });
+      return;
+    }
+    if (!expr.has(variable)) return;
+    if (isNumber(expr)) return;
+    const deg = polynomialDegree(expr, variable);
+    result.push({ factor: expr, multiplicity: 1, degree: deg });
+  }
+  function solveLinearSystem(matrix, numVars) {
+    const rows = matrix.length;
+    const cols = numVars + 1;
+    const m = matrix.map((row) => [...row]);
+    const pivotRow = new Array(numVars).fill(-1);
+    let currentRow = 0;
+    for (let col = 0; col < numVars && currentRow < rows; col++) {
+      let maxVal = 0;
+      let maxRow = -1;
+      for (let row = currentRow; row < rows; row++) {
+        const absVal = Math.abs(m[row][col]);
+        if (absVal > maxVal) {
+          maxVal = absVal;
+          maxRow = row;
+        }
+      }
+      if (maxVal === 0) continue;
+      if (maxRow !== currentRow) {
+        [m[currentRow], m[maxRow]] = [m[maxRow], m[currentRow]];
+      }
+      pivotRow[col] = currentRow;
+      for (let row = 0; row < rows; row++) {
+        if (row === currentRow) continue;
+        if (m[row][col] === 0) continue;
+        const factor3 = m[row][col];
+        const pivotVal = m[currentRow][col];
+        for (let j = 0; j < cols; j++) {
+          m[row][j] = m[row][j] * pivotVal - factor3 * m[currentRow][j];
+        }
+      }
+      currentRow++;
+    }
+    const solution = new Array(numVars);
+    for (let col = 0; col < numVars; col++) {
+      const pr = pivotRow[col];
+      if (pr === -1) {
+        solution[col] = [0, 1];
+        continue;
+      }
+      const num = m[pr][cols - 1];
+      const den = m[pr][col];
+      if (den === 0) return null;
+      const g = gcd4(Math.abs(num), Math.abs(den));
+      const sign3 = den < 0 ? -1 : 1;
+      solution[col] = [sign3 * num / g, sign3 * den / g];
+    }
+    return solution;
+  }
+  function gcd4(a, b) {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while (b) {
+      [a, b] = [b, a % b];
+    }
+    return a || 1;
+  }
+  function partialFraction(expr, variable) {
+    const ce = expr.engine;
+    if (!isFunction2(expr, "Divide")) return expr;
+    const numer = expr.op1;
+    const denom = expr.op2;
+    const numerDeg = polynomialDegree(numer, variable);
+    const denomDeg = polynomialDegree(denom, variable);
+    if (numerDeg < 0 || denomDeg < 0) return expr;
+    if (denomDeg === 0) return expr;
+    let quotient = null;
+    let remainder2;
+    if (numerDeg >= denomDeg) {
+      const divResult = polynomialDivide(numer, denom, variable);
+      if (!divResult) return expr;
+      quotient = divResult[0];
+      remainder2 = divResult[1];
+      const remCoeffs2 = getPolynomialCoefficients(remainder2, variable);
+      if (remCoeffs2 && remCoeffs2.every((c) => c.isSame(0))) {
+        return quotient;
+      }
+    } else {
+      remainder2 = numer;
+    }
+    const factoredDenom = factorPolynomial(denom, variable);
+    const factors = collectFactors(factoredDenom, variable);
+    if (factors.length === 0) return expr;
+    if (factors.length === 1 && factors[0].multiplicity === 1) {
+      if (quotient) return quotient.add(remainder2.div(denom));
+      return expr;
+    }
+    for (const f of factors) {
+      if (f.degree > 2 || f.degree < 0) return expr;
+    }
+    let totalFactorDeg = 0;
+    for (const f of factors) {
+      totalFactorDeg += f.degree * f.multiplicity;
+    }
+    if (totalFactorDeg !== denomDeg) return expr;
+    const templateTerms = [];
+    let unknownCount = 0;
+    for (const f of factors) {
+      for (let k = 1; k <= f.multiplicity; k++) {
+        if (f.degree === 1) {
+          templateTerms.push({
+            isLinear: true,
+            factor: f.factor,
+            power: k,
+            unknownIndex: unknownCount
+          });
+          unknownCount++;
+        } else {
+          templateTerms.push({
+            isLinear: false,
+            factor: f.factor,
+            power: k,
+            unknownIndex: unknownCount
+          });
+          unknownCount += 2;
+        }
+      }
+    }
+    if (unknownCount !== denomDeg) return expr;
+    const expandedDenom = expand2(denom);
+    const denomCoeffs = getPolynomialCoefficients(expandedDenom, variable);
+    if (!denomCoeffs) return expr;
+    const expandedRemainder = expand2(remainder2);
+    const remCoeffs = getPolynomialCoefficients(expandedRemainder, variable);
+    if (!remCoeffs) return expr;
+    const systemRows = denomDeg;
+    const augMatrix = [];
+    for (let i = 0; i < systemRows; i++) {
+      augMatrix.push(new Array(unknownCount + 1).fill(0));
+    }
+    for (let i = 0; i < systemRows; i++) {
+      const coeff = i < remCoeffs.length ? asSmallInteger(remCoeffs[i]) : 0;
+      if (coeff === null) return expr;
+      augMatrix[i][unknownCount] = coeff;
+    }
+    for (const t of templateTerms) {
+      let termDenom;
+      if (t.power === 1) {
+        termDenom = t.factor;
+      } else {
+        termDenom = ce.box(["Power", t.factor.json, t.power]);
+      }
+      const cofactorResult = polynomialDivide(expandedDenom, termDenom, variable);
+      if (!cofactorResult) return expr;
+      const cofactor = cofactorResult[0];
+      const cofRem = cofactorResult[1];
+      const cofRemCoeffs = getPolynomialCoefficients(cofRem, variable);
+      if (!cofRemCoeffs || !cofRemCoeffs.every((c) => c.isSame(0))) return expr;
+      const expandedCofactor = expand2(cofactor);
+      const cofCoeffs = getPolynomialCoefficients(expandedCofactor, variable);
+      if (!cofCoeffs) return expr;
+      const intCofCoeffs = [];
+      for (let i = 0; i < systemRows; i++) {
+        const c = i < cofCoeffs.length ? asSmallInteger(cofCoeffs[i]) : 0;
+        if (c === null) return expr;
+        intCofCoeffs.push(c);
+      }
+      if (t.isLinear) {
+        for (let i = 0; i < systemRows; i++) {
+          augMatrix[i][t.unknownIndex] += intCofCoeffs[i];
+        }
+      } else {
+        const aIdx = t.unknownIndex;
+        const bIdx = t.unknownIndex + 1;
+        for (let i = 0; i < systemRows; i++) {
+          augMatrix[i][bIdx] += intCofCoeffs[i];
+          if (i > 0) {
+            augMatrix[i][aIdx] += intCofCoeffs[i - 1];
+          }
+        }
+      }
+    }
+    const solution = solveLinearSystem(augMatrix, unknownCount);
+    if (!solution) return expr;
+    const x = ce.symbol(variable);
+    const partialTerms = [];
+    if (quotient) partialTerms.push(quotient);
+    for (const t of templateTerms) {
+      let termDenom;
+      if (t.power === 1) {
+        termDenom = t.factor;
+      } else {
+        termDenom = ce.box(["Power", t.factor.json, t.power]);
+      }
+      let termNumer;
+      if (t.isLinear) {
+        const [num, den] = solution[t.unknownIndex];
+        if (num === 0) continue;
+        termNumer = den === 1 ? ce.number(num) : ce.number(num).div(ce.number(den));
+      } else {
+        const [aNum, aDen] = solution[t.unknownIndex];
+        const [bNum, bDen] = solution[t.unknownIndex + 1];
+        if (aNum === 0 && bNum === 0) continue;
+        const terms = [];
+        if (aNum !== 0) {
+          const aCoeff = aDen === 1 ? ce.number(aNum) : ce.number(aNum).div(ce.number(aDen));
+          terms.push(aCoeff.mul(x));
+        }
+        if (bNum !== 0) {
+          const bCoeff = bDen === 1 ? ce.number(bNum) : ce.number(bNum).div(ce.number(bDen));
+          terms.push(bCoeff);
+        }
+        termNumer = terms.length === 1 ? terms[0] : add3(...terms);
+      }
+      partialTerms.push(termNumer.div(termDenom));
+    }
+    if (partialTerms.length === 0) return ce.Zero;
+    if (partialTerms.length === 1) return partialTerms[0];
+    return add3(...partialTerms);
+  }
 
   // src/compute-engine/symbolic/distribute.ts
   function distribute2(lhs, rhs, g, f) {
@@ -38402,7 +38852,7 @@ ${e.message}
         }
       },
       CoefficientList: {
-        description: "Return the list of coefficients of a polynomial, from lowest to highest degree. Example: CoefficientList(x\xB3 + 2x + 1, x) \u2192 [1, 2, 0, 1]",
+        description: "Return the list of coefficients of a polynomial, from highest to lowest degree. Example: CoefficientList(x\xB3 + 2x + 1, x) \u2192 [1, 0, 2, 1]",
         lazy: true,
         signature: "(value, symbol) -> list<value>",
         evaluate: ([poly, varExpr]) => {
@@ -38411,7 +38861,7 @@ ${e.message}
           if (!variable) return void 0;
           const coeffs = getPolynomialCoefficients(poly.canonical, variable);
           if (!coeffs) return void 0;
-          return poly.engine.box(["List", ...coeffs]);
+          return poly.engine.box(["List", ...coeffs.reverse()]);
         }
       },
       PolynomialQuotient: {
@@ -38467,6 +38917,85 @@ ${e.message}
           if (!variable) return void 0;
           return cancelCommonFactors(expr.canonical, variable);
         }
+      },
+      PartialFraction: {
+        description: "Decompose a rational expression into partial fractions. Example: PartialFraction(1/((x+1)(x+2)), x) \u2192 1/(x+1) - 1/(x+2)",
+        lazy: true,
+        signature: "(value, symbol) -> value",
+        evaluate: ([expr, varExpr]) => {
+          if (!expr || !varExpr) return void 0;
+          const variable = sym(varExpr.canonical);
+          if (!variable) return void 0;
+          return partialFraction(expr.canonical, variable);
+        }
+      },
+      Apart: {
+        description: "Alias for PartialFraction. Decompose a rational expression into partial fractions.",
+        lazy: true,
+        signature: "(value, symbol) -> value",
+        evaluate: ([expr, varExpr]) => {
+          if (!expr || !varExpr) return void 0;
+          const variable = sym(varExpr.canonical);
+          if (!variable) return void 0;
+          return partialFraction(expr.canonical, variable);
+        }
+      },
+      PolynomialRoots: {
+        description: "Return the roots of a polynomial expression. Example: PolynomialRoots(x\xB2 - 5x + 6, x) \u2192 {2, 3}",
+        lazy: true,
+        signature: "(value, symbol) -> set<value>",
+        evaluate: ([poly, varExpr]) => {
+          if (!poly || !varExpr) return void 0;
+          const variable = sym(varExpr.canonical);
+          if (!variable) return void 0;
+          const roots = poly.canonical.polynomialRoots(variable);
+          if (!roots || roots.length === 0) return void 0;
+          return poly.engine.box(["Set", ...roots.map((r) => r.json)]);
+        }
+      },
+      Discriminant: {
+        description: "Return the discriminant of a polynomial. Example: Discriminant(x\xB2 - 5x + 6, x) \u2192 1",
+        lazy: true,
+        signature: "(value, symbol) -> value",
+        evaluate: ([poly, varExpr]) => {
+          if (!poly || !varExpr) return void 0;
+          const variable = sym(varExpr.canonical);
+          if (!variable) return void 0;
+          const coeffsAsc = getPolynomialCoefficients(poly.canonical, variable);
+          if (!coeffsAsc) return void 0;
+          const coeffs = [...coeffsAsc].reverse();
+          const degree = coeffs.length - 1;
+          const ce = poly.engine;
+          if (degree === 2) {
+            const [a, b, c] = coeffs;
+            return b.mul(b).sub(ce.number(4).mul(a).mul(c));
+          }
+          if (degree === 3) {
+            const [a, b, c, d] = coeffs;
+            return b.mul(b).mul(c).mul(c).sub(ce.number(4).mul(a).mul(c).mul(c).mul(c)).sub(ce.number(4).mul(b).mul(b).mul(b).mul(d)).add(ce.number(18).mul(a).mul(b).mul(c).mul(d)).sub(ce.number(27).mul(a).mul(a).mul(d).mul(d));
+          }
+          if (degree === 4) {
+            const [a, b, c, d, e] = coeffs;
+            return ce.number(256).mul(a).mul(a).mul(a).mul(e).mul(e).mul(e).sub(ce.number(192).mul(a).mul(a).mul(b).mul(d).mul(e).mul(e)).sub(ce.number(128).mul(a).mul(a).mul(c).mul(c).mul(e).mul(e)).add(ce.number(144).mul(a).mul(a).mul(c).mul(d).mul(d).mul(e)).sub(ce.number(27).mul(a).mul(a).mul(d).mul(d).mul(d).mul(d)).add(ce.number(144).mul(a).mul(b).mul(b).mul(c).mul(e).mul(e)).sub(ce.number(6).mul(a).mul(b).mul(b).mul(d).mul(d).mul(e)).sub(ce.number(80).mul(a).mul(b).mul(c).mul(c).mul(d).mul(e)).add(ce.number(18).mul(a).mul(b).mul(c).mul(d).mul(d).mul(d)).add(ce.number(16).mul(a).mul(c).mul(c).mul(c).mul(c).mul(e)).sub(ce.number(4).mul(a).mul(c).mul(c).mul(c).mul(d).mul(d)).sub(ce.number(27).mul(b).mul(b).mul(b).mul(b).mul(e).mul(e)).add(ce.number(18).mul(b).mul(b).mul(b).mul(c).mul(d).mul(e)).sub(ce.number(4).mul(b).mul(b).mul(b).mul(d).mul(d).mul(d)).sub(ce.number(4).mul(b).mul(b).mul(c).mul(c).mul(c).mul(e)).add(b.mul(b).mul(c).mul(c).mul(d).mul(d));
+          }
+          return void 0;
+        }
+      },
+      Polynomial: {
+        description: "Construct a polynomial from a list of coefficients (highest to lowest degree) and a variable. Example: Polynomial([1, 0, 2, 1], x) \u2192 x\xB3 + 2x + 1",
+        lazy: true,
+        signature: "(list<value>, symbol) -> value",
+        evaluate: ([coeffList, varExpr]) => {
+          if (!coeffList || !varExpr) return void 0;
+          const variable = sym(varExpr.canonical);
+          if (!variable) return void 0;
+          const canonical2 = coeffList.canonical;
+          if (!isFunction2(canonical2, "List")) return void 0;
+          const coeffs = canonical2.ops;
+          if (coeffs.length === 0) return void 0;
+          const ascending = [...coeffs].reverse();
+          return fromCoefficients(ascending, variable);
+        }
       }
     }
   ];
@@ -46465,7 +46994,7 @@ Error in definition of "${name}"`,
     };
     return checkTerm(expr);
   }
-  function solveLinearSystem(equations, variables) {
+  function solveLinearSystem2(equations, variables) {
     if (equations.length === 0 || variables.length === 0) return null;
     const ce = equations[0].engine;
     const n = variables.length;
@@ -47450,6 +47979,15 @@ Error in definition of "${name}"`,
       } else if (operator2 === expr.operator) {
         const matchPerms = options.matchPermutations ?? true;
         result = pattern.operatorDefinition.commutative && matchPerms ? matchPermutation(expr, pattern, substitution, options) : matchArguments(expr, pattern.ops, substitution, options);
+        if (result === null && options.matchMissingTerms && isFunction2(expr) && isFunction2(pattern) && expr.nops < pattern.nops) {
+          result = matchWithMissingTerms(
+            expr,
+            pattern,
+            substitution,
+            options,
+            ce
+          );
+        }
       }
       if (result === null && useVariations) {
         if (!acceptVariants) return null;
@@ -47747,8 +48285,8 @@ Error in definition of "${name}"`,
         const minCapture = 1;
         const maxCapture2 = remaining.length - countMinNeeded(restWildcards);
         for (let count = maxCapture2; count >= minCapture; count--) {
-          const combinations = getCombinations(remaining.length, count);
-          for (const indices of combinations) {
+          const combinations2 = getCombinations(remaining.length, count);
+          for (const indices of combinations2) {
             const captured = indices.map((i) => remaining[i]);
             const capturedExpr = wrapCaptured(captured);
             const newSub = captureWildcard(wcName, capturedExpr, sub3);
@@ -47777,8 +48315,8 @@ Error in definition of "${name}"`,
             if (result !== null) return result;
           }
         } else {
-          const combinations = getCombinations(remaining.length, count);
-          for (const indices of combinations) {
+          const combinations2 = getCombinations(remaining.length, count);
+          for (const indices of combinations2) {
             const captured = indices.map((i) => remaining[i]);
             const capturedExpr = wrapCaptured(captured);
             const newSub = captureWildcard(wcName, capturedExpr, sub3);
@@ -47952,17 +48490,140 @@ Error in definition of "${name}"`,
       }
     }
   }
+  function matchWithMissingTerms(expr, pattern, substitution, options, ce) {
+    if (!isFunction2(expr) || !isFunction2(pattern)) return null;
+    const operator2 = expr.operator;
+    const identity = operator2 === "Add" ? ce.Zero : operator2 === "Multiply" ? ce.One : null;
+    if (!identity) return null;
+    const patOps = pattern.ops;
+    const missing = patOps.length - expr.nops;
+    if (missing <= 0) return null;
+    const combos = combinations(patOps.length, missing);
+    combos.sort((a, b) => {
+      const scoreA = a.reduce((s, i) => s + patternComplexity(patOps[i]), 0);
+      const scoreB = b.reduce((s, i) => s + patternComplexity(patOps[i]), 0);
+      return scoreA - scoreB;
+    });
+    for (const identityIndices of combos) {
+      const activePatOps = patOps.filter((_, i) => !identityIndices.includes(i));
+      const identityPatOps = identityIndices.map((i) => patOps[i]);
+      const subPattern = ce.function(operator2, activePatOps, { form: "raw" });
+      let sub3 = matchPermutation(expr, subPattern, substitution, options);
+      if (sub3 === null) continue;
+      let failed = false;
+      for (const patOp of identityPatOps) {
+        const result = matchIdentityTerm(patOp, identity, sub3, options, ce);
+        if (result === null) {
+          failed = true;
+          break;
+        }
+        sub3 = result;
+      }
+      if (!failed) return sub3;
+    }
+    return null;
+  }
+  function matchIdentityTerm(patOp, identity, sub3, options, ce) {
+    const result = matchOnce(identity, patOp, sub3, options);
+    if (result !== null) return result;
+    if (identity.isSame(0) && isFunction2(patOp, "Multiply")) {
+      for (const op of patOp.ops) {
+        const wn = wildcardName(op);
+        if (wn && !(wn in sub3)) {
+          return captureWildcard(wn, identity, sub3);
+        }
+      }
+    }
+    if (identity.isSame(1) && isFunction2(patOp, "Power")) {
+      const expOp = patOp.ops[1];
+      if (expOp) {
+        const wn = wildcardName(expOp);
+        if (wn && !(wn in sub3)) {
+          return captureWildcard(wn, ce.Zero, sub3);
+        }
+      }
+    }
+    return null;
+  }
+  function patternComplexity(expr) {
+    if (isWildcard(expr)) return 0;
+    if (isNumber(expr) || isSymbol2(expr) || isString(expr)) return 1;
+    if (isFunction2(expr))
+      return 1 + expr.ops.reduce((s, op) => s + patternComplexity(op), 0);
+    return 1;
+  }
+  function combinations(n, k) {
+    const result = [];
+    const combo = [];
+    function backtrack(start) {
+      if (combo.length === k) {
+        result.push([...combo]);
+        return;
+      }
+      for (let i = start; i < n; i++) {
+        combo.push(i);
+        backtrack(i + 1);
+        combo.pop();
+      }
+    }
+    backtrack(0);
+    return result;
+  }
   function match(subject, pattern, options) {
-    pattern = pattern.structural;
-    const useVariations = options?.useVariations ?? false;
+    const ce = subject.engine;
+    let autoWildcard = false;
+    let boxedPattern;
+    if (typeof pattern === "string") {
+      autoWildcard = true;
+      boxedPattern = ce.parse(pattern).map(
+        (x) => isSymbol2(x) && x.symbol.length === 1 ? ce.symbol("_" + x.symbol) : x,
+        { canonical: false }
+      );
+    } else if ("engine" in pattern) {
+      boxedPattern = pattern;
+    } else {
+      boxedPattern = ce.box(pattern);
+    }
+    boxedPattern = boxedPattern.structural;
+    const useVariations = options?.useVariations ?? autoWildcard;
     const opts = {
       recursive: options?.recursive ?? false,
       useVariations,
       acceptVariants: useVariations,
-      matchPermutations: options?.matchPermutations ?? true
+      matchPermutations: options?.matchPermutations ?? true,
+      matchMissingTerms: options?.matchMissingTerms ?? autoWildcard
     };
-    const substitution = options?.substitution ?? {};
-    return matchOnce(subject.structural, pattern.structural, substitution, opts);
+    let substitution = options?.substitution ?? {};
+    if (autoWildcard && Object.keys(substitution).length > 0) {
+      const prefixed = {};
+      for (const [k, v] of Object.entries(substitution)) {
+        if (k.startsWith("_")) {
+          prefixed[k] = v;
+        } else {
+          if (!(`_${k}` in substitution)) prefixed[`_${k}`] = v;
+          prefixed[k] = v;
+        }
+      }
+      substitution = prefixed;
+    }
+    const result = matchOnce(
+      subject.structural,
+      boxedPattern.structural,
+      substitution,
+      opts
+    );
+    if (!result) return null;
+    if (autoWildcard) {
+      const clean = {};
+      for (const [k, v] of Object.entries(result)) {
+        if (!k.startsWith("_")) continue;
+        const name = k.slice(1);
+        if (isSymbol2(v) && v.symbol === name) continue;
+        clean[name] = v;
+      }
+      return clean;
+    }
+    return result;
   }
 
   // src/compute-engine/boxed-expression/sgn.ts
@@ -48818,7 +49479,7 @@ Error in definition of "${name}"`,
   };
   function solveSystem(ce, equations, varNames) {
     if (equations && equations.every((eq2) => eq2.operator === "Equal")) {
-      const linearResult = solveLinearSystem([...equations], varNames);
+      const linearResult = solveLinearSystem2([...equations], varNames);
       if (linearResult && filterSolutionByTypes(ce, varNames, linearResult))
         return linearResult;
       const polyResult = solvePolynomialSystem([...equations], varNames);
@@ -48848,7 +49509,7 @@ Error in definition of "${name}"`,
         (eq2) => inequalityOps.includes(eq2.operator ?? "")
       );
       if (equalities.length > 0 && inequalities.length > 0 && equalities.length + inequalities.length === equations.length) {
-        const linearResult = solveLinearSystem([...equalities], varNames);
+        const linearResult = solveLinearSystem2([...equalities], varNames);
         if (linearResult) {
           if (satisfiesInequalities(linearResult, inequalities))
             return filterSolutionByTypes(ce, varNames, linearResult) ? linearResult : null;
@@ -50489,11 +51150,7 @@ Error in definition of "${name}"`,
       if (h === "Function") {
         const fnFn = target.functions?.(h);
         if (typeof fnFn === "function")
-          return fnFn(
-            args,
-            (expr) => _BaseCompiler.compile(expr, target),
-            target
-          );
+          return fnFn(args, (expr) => _BaseCompiler.compile(expr, target), target);
         const params = args.slice(1).map((x) => isSymbol2(x) ? x.symbol : "_");
         return `((${params.join(", ")}) => ${_BaseCompiler.compile(
           args[0].canonical,
@@ -50622,7 +51279,10 @@ Error in definition of "${name}"`,
       };
       const result = args.filter((a) => !isSymbol2(a, "Nothing")).map((arg) => {
         if (isFunction2(arg, "Declare") && isSymbol2(arg.ops[0]) && target.declare) {
-          return target.declare(arg.ops[0].symbol, typeHints[arg.ops[0].symbol]);
+          return target.declare(
+            arg.ops[0].symbol,
+            typeHints[arg.ops[0].symbol]
+          );
         }
         return _BaseCompiler.compile(arg, localTarget);
       }).filter((s) => s !== "");
@@ -51113,6 +51773,9 @@ Error in definition of "${name}"`,
   _setSerializeJson(serializeJson);
   _setProduct(Product);
   _setCompile(compile);
+  _setGetPolynomialCoefficients(getPolynomialCoefficients);
+  _setGetPolynomialDegree(polynomialDegree);
+  _setFindUnivariateRoots(findUnivariateRoots);
 
   // src/compute-engine/symbolic/simplify-logic.ts
   function simplifyLogicFunction(x) {
@@ -54051,6 +54714,27 @@ Error in definition of "${name}"`,
       if (result.isSame(x)) return void 0;
       return { value: result, because: "cancel common polynomial factors" };
     },
+    //
+    // Auto partial fraction decomposition for Divide with factored denominator
+    // e.g., 1/((x+1)(x+2)) → 1/(x+1) - 1/(x+2)
+    // Only triggers when denominator is already in factored form (Multiply or Power)
+    //
+    // IMPORTANT: partialFraction must not call .simplify() on its result
+    //
+    (x) => {
+      if (!isFunction2(x, "Divide")) return void 0;
+      const denom = x.op2;
+      const denomOp = denom.operator;
+      if (denomOp !== "Multiply" && denomOp !== "Power") return void 0;
+      const unknowns = x.unknowns;
+      if (unknowns.length !== 1) return void 0;
+      const variable = unknowns[0];
+      const result = partialFraction(x, variable);
+      if (result.isSame(x)) return void 0;
+      const ce = x.engine;
+      if (ce.costFunction(result) >= ce.costFunction(x)) return void 0;
+      return { value: result, because: "partial fraction decomposition" };
+    },
     // Quick a/a -> 1 check for identical numerator/denominator
     // Must run before expand to avoid decomposing the fraction first
     (x) => {
@@ -57815,7 +58499,8 @@ Error in definition of "${name}"`,
       return `_gpu_fresnelS(${compile3(x)})`;
     },
     BesselJ: ([n, x], compile3, target) => {
-      if (n === null || x === null) throw new Error("BesselJ: need two arguments");
+      if (n === null || x === null)
+        throw new Error("BesselJ: need two arguments");
       const intCast = target?.language === "wgsl" ? "i32" : "int";
       return `_gpu_besselJ(${intCast}(${compile3(n)}), ${compile3(x)})`;
     },
@@ -57917,8 +58602,7 @@ Error in definition of "${name}"`,
         throw new Error("Loop: expected Element(index, Range(lo, hi))");
       const indexExpr = indexing.ops[0];
       const rangeExpr = indexing.ops[1];
-      if (!isSymbol2(indexExpr))
-        throw new Error("Loop: index must be a symbol");
+      if (!isSymbol2(indexExpr)) throw new Error("Loop: index must be a symbol");
       if (!isFunction2(rangeExpr, "Range"))
         throw new Error("Loop: expected Range(lo, hi)");
       const index = indexExpr.symbol;
@@ -59170,7 +59854,9 @@ ${indented};
       const params = parameters.map(([name, type2]) => `${name}: ${toWGSLType(type2)}`).join(", ");
       if (body.includes("\n")) {
         const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
-        return `fn ${functionName}(${params}) -> ${toWGSLType(returnType)} {
+        return `fn ${functionName}(${params}) -> ${toWGSLType(
+          returnType
+        )} {
 ${indented};
 }`;
       }
@@ -59818,7 +60504,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     ];
     return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
   }
-  function gcd4(a, b) {
+  function gcd5(a, b) {
     const uA = unwrapOrPropagate(a);
     if (!Array.isArray(uA)) return uA;
     const uB = unwrapOrPropagate(b);
@@ -60470,7 +61156,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     factorial: factorial5,
     factorial2: factorial24,
     binomial: binomial2,
-    gcd: gcd4,
+    gcd: gcd5,
     lcm: lcm4,
     chop: chop4,
     erf: erf2,
@@ -64249,6 +64935,11 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       if (this.atEnd) return lhs;
       console.assert(lhs !== null);
       const index = this.index;
+      if (this.options.strict === false && typeof lhs === "string" && lhs.length === 1 && /^[a-zA-Z]$/.test(lhs) && /^[2-9]$/.test(this.peek)) {
+        const digit = parseInt(this.peek);
+        this.index++;
+        return this.parseSupsub(["Power", lhs, digit]);
+      }
       this.skipSpace();
       const superscripts = [];
       const subscripts = [];
@@ -66353,9 +67044,9 @@ ${code}`;
     return ce._fn("Tan", [tanCArg]).neg();
   }
   function lcm5(a, b) {
-    return Math.abs(a * b) / gcd5(a, b);
+    return Math.abs(a * b) / gcd6(a, b);
   }
-  function gcd5(a, b) {
+  function gcd6(a, b) {
     a = Math.abs(a);
     b = Math.abs(b);
     while (b) {
@@ -68041,10 +68732,10 @@ ${code}`;
   _setComputeEngineClass(ComputeEngine);
 
   // src/compute-engine.ts
-  var version = "0.53.1";
+  var version = "0.54.0";
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.53.1"
+    version: "0.54.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();