@cortex-js/compute-engine 0.53.1 → 0.54.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.53.1 */
+/** Compute Engine 0.54.1 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -12290,6 +12290,18 @@ var _expandForIs;
 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;
@@ -12605,6 +12617,34 @@ var _BoxedExpression = class __BoxedExpression {
   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)) {
@@ -16064,10 +16104,14 @@ function isSqrt(expr) {
   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;
@@ -23948,7 +23992,9 @@ var ARITHMETIC_LIBRARY = [
         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));
       }
     },
@@ -26349,6 +26395,268 @@ function expandAll(expr) {
   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;
@@ -27172,6 +27480,13 @@ function findUnivariateRoots(expr, x) {
         )
       );
     }
+    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();
   }
@@ -27310,267 +27625,49 @@ function filterRootsByType(ce, x, roots) {
     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
@@ -38214,7 +38311,107 @@ function factorQuadratic(expr, variable) {
     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);
@@ -38222,6 +38419,8 @@ function factorPolynomial(expr, variable) {
   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);
 }
@@ -38267,6 +38466,257 @@ function factor(expr) {
   }
   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) {
@@ -38341,7 +38791,7 @@ var POLYNOMIALS_LIBRARY = [
       }
     },
     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]) => {
@@ -38350,7 +38800,7 @@ var POLYNOMIALS_LIBRARY = [
         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: {
@@ -38406,6 +38856,85 @@ var POLYNOMIALS_LIBRARY = [
         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);
+      }
     }
   }
 ];
@@ -46404,7 +46933,7 @@ function isLinearInVariables(expr, variables) {
   };
   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;
@@ -47389,6 +47918,15 @@ function matchOnce(expr, pattern, substitution, options) {
     } 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;
@@ -47686,8 +48224,8 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
       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);
@@ -47716,8 +48254,8 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
           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);
@@ -47891,17 +48429,140 @@ function matchArguments(expr, patterns, substitution, options) {
     }
   }
 }
+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
@@ -48757,7 +49418,7 @@ var BoxedFunction = class extends _BoxedExpression {
 };
 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);
@@ -48787,7 +49448,7 @@ function solveSystem(ce, equations, varNames) {
       (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;
@@ -50428,11 +51089,7 @@ var BaseCompiler = class _BaseCompiler {
     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,
@@ -50561,7 +51218,10 @@ var BaseCompiler = class _BaseCompiler {
     };
     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 !== "");
@@ -51052,6 +51712,9 @@ _setExpandForIs(expand2);
 _setSerializeJson(serializeJson);
 _setProduct(Product);
 _setCompile(compile);
+_setGetPolynomialCoefficients(getPolynomialCoefficients);
+_setGetPolynomialDegree(polynomialDegree);
+_setFindUnivariateRoots(findUnivariateRoots);
 
 // src/compute-engine/symbolic/simplify-logic.ts
 function simplifyLogicFunction(x) {
@@ -53990,6 +54653,27 @@ var SIMPLIFY_RULES = [
     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) => {
@@ -57754,7 +58438,8 @@ var GPU_FUNCTIONS = {
     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)})`;
   },
@@ -57856,8 +58541,7 @@ var GPU_FUNCTIONS = {
       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;
@@ -59109,7 +59793,9 @@ var WGSLTarget = class extends GPUShaderTarget {
     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};
 }`;
     }
@@ -59757,7 +60443,7 @@ function binomial2(n, k) {
   ];
   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);
@@ -60409,7 +61095,7 @@ var IntervalArithmetic = {
   factorial: factorial5,
   factorial2: factorial24,
   binomial: binomial2,
-  gcd: gcd4,
+  gcd: gcd5,
   lcm: lcm4,
   chop: chop4,
   erf: erf2,
@@ -64188,6 +64874,11 @@ var _Parser = class __Parser {
     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 = [];
@@ -66292,9 +66983,9 @@ function TR12i(expr) {
   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) {
@@ -67980,10 +68671,10 @@ var ComputeEngine = class _ComputeEngine {
 _setComputeEngineClass(ComputeEngine);
 
 // src/compute-engine.ts
-var version = "0.53.1";
+var version = "0.54.1";
 globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.53.1"
+  version: "0.54.1"
 };
 export {
   BaseCompiler,