@cortex-js/compute-engine 0.31.0 → 0.32.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.31.0 */
+/** Compute Engine 0.32.1 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -7841,7 +7841,11 @@ function serializePower(serializer, expr) {
         if (denom === 2) {
           return serializer.serialize(["Divide", "1", ["Sqrt", base]]);
         }
-        return serializer.serialize(["Divide", "1", ["Root", base, denom]]);
+        return serializer.serialize([
+          "Divide",
+          "1",
+          ["Root", base, operand(exp2, 2)]
+        ]);
       }
       if (denom === 2) {
         return `${serializer.serialize(["Sqrt", base])}^{${serializer.serialize(
@@ -7855,13 +7859,20 @@ function serializePower(serializer, expr) {
       }
     }
   }
+  const wrapNegativeBase = (latex) => latex.startsWith("-") ? serializer.wrapString(latex, "normal") : latex;
   if (operator(base) === "Power") {
     const baseBody = operand(base, 1);
     const baseExponent = operand(base, 2);
+    const baseBodyLatex = wrapNegativeBase(serializer.wrapShort(baseBody));
+    const baseExponentLatex = serializer.wrapShort(baseExponent);
     return `
-      ${serializer.wrapShort(baseBody)}^{${supsub("^", serializer.wrapShort(baseExponent), serializer.serialize(exp2))}}`;
+      ${baseBodyLatex}^{${supsub("^", baseExponentLatex, serializer.serialize(exp2))}}`;
   }
-  return supsub("^", serializer.wrapShort(base), serializer.serialize(exp2));
+  return supsub(
+    "^",
+    wrapNegativeBase(serializer.wrapShort(base)),
+    serializer.serialize(exp2)
+  );
 }
 var DEFINITIONS_ARITHMETIC = [
   // Constants
@@ -8142,8 +8153,9 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "GCD",
-    latexTrigger: ["\\gcd"]
+    latexTrigger: ["\\gcd"],
     // command from amsmath package
+    kind: "function"
   },
   {
     symbolTrigger: "gcd",
@@ -8201,9 +8213,14 @@ var DEFINITIONS_ARITHMETIC = [
   },
   {
     name: "LCM",
-    symbolTrigger: "lcm",
+    latexTrigger: ["\\lcm"],
     kind: "function"
   },
+  {
+    symbolTrigger: "lcm",
+    kind: "function",
+    parse: "LCM"
+  },
   {
     symbolTrigger: "LCM",
     kind: "function",
@@ -8477,7 +8494,11 @@ var DEFINITIONS_ARITHMETIC = [
   {
     name: "Square",
     precedence: 720,
-    serialize: (serializer, expr) => serializer.wrapShort(operand(expr, 1)) + "^2"
+    serialize: (serializer, expr) => {
+      const base = serializer.wrapShort(operand(expr, 1));
+      const wrapped = base.startsWith("-") ? serializer.wrapString(base, "normal") : base;
+      return wrapped + "^2";
+    }
   },
   {
     latexTrigger: ["\\sum"],
@@ -10587,40 +10608,43 @@ var DEFINITIONS_LOGIC = [
     parse: "False"
   },
   // Operators
+  // Logic operators have lower precedence than comparisons (245)
+  // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
+  // See https://github.com/cortex-js/compute-engine/issues/243
   {
     name: "And",
     kind: "infix",
     latexTrigger: ["\\land"],
-    precedence: 317
+    precedence: 235
     // serialize: '\\land',
   },
-  { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 317 },
-  { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 317 },
+  { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
+  { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
   {
     kind: "infix",
     latexTrigger: "\\operatorname{and}",
     parse: "And",
-    precedence: 317
+    precedence: 235
   },
   {
     name: "Or",
     kind: "infix",
     latexTrigger: ["\\lor"],
-    precedence: 310
+    precedence: 230
   },
-  { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 310 },
-  { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 310 },
+  { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
+  { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
   {
     kind: "infix",
     latexTrigger: "\\operatorname{or}",
     parse: "Or",
-    precedence: 310
+    precedence: 230
   },
   {
     name: "Xor",
     kind: "infix",
     latexTrigger: ["\\veebar"],
-    precedence: 315
+    precedence: 232
   },
   // Possible alt: \oplus ⊕ U+2295
   {
@@ -10639,7 +10663,7 @@ var DEFINITIONS_LOGIC = [
     name: "Nand",
     kind: "infix",
     latexTrigger: ["\\barwedge"],
-    precedence: 315
+    precedence: 232
     // serialize: '\\mid',
   },
   {
@@ -10647,7 +10671,7 @@ var DEFINITIONS_LOGIC = [
     kind: "infix",
     latexTrigger: ["\u22BD"],
     // bar vee
-    precedence: 315
+    precedence: 232
     // serialize: '\\downarrow',
   },
   // Functions
@@ -10743,7 +10767,7 @@ var DEFINITIONS_LOGIC = [
     latexTrigger: ["\\forall"],
     precedence: 200,
     // Has to be lower than COMPARISON_PRECEDENCE
-    serialize: "\\forall",
+    serialize: serializeQuantifier("\\forall"),
     parse: parseQuantifier("ForAll")
   },
   {
@@ -10752,7 +10776,7 @@ var DEFINITIONS_LOGIC = [
     latexTrigger: ["\\exists"],
     precedence: 200,
     // Has to be lower than COMPARISON_PRECEDENCE,
-    serialize: "\\exists",
+    serialize: serializeQuantifier("\\exists"),
     parse: parseQuantifier("Exists")
   },
   {
@@ -10761,7 +10785,7 @@ var DEFINITIONS_LOGIC = [
     latexTrigger: ["\\exists", "!"],
     precedence: 200,
     // Has to be lower than COMPARISON_PRECEDENCE,
-    serialize: "\\exists!",
+    serialize: serializeQuantifier("\\exists!"),
     parse: parseQuantifier("ExistsUnique")
   },
   {
@@ -10770,7 +10794,7 @@ var DEFINITIONS_LOGIC = [
     latexTrigger: ["\\lnot", "\\forall"],
     precedence: 200,
     // Has to be lower than COMPARISON_PRECEDENCE
-    serialize: "\\lnot\\forall",
+    serialize: serializeQuantifier("\\lnot\\forall"),
     parse: parseQuantifier("NotForAll")
   },
   {
@@ -10779,7 +10803,7 @@ var DEFINITIONS_LOGIC = [
     latexTrigger: ["\\lnot", "\\exists"],
     precedence: 200,
     // Has to be lower than COMPARISON_PRECEDENCE,
-    serialize: "\\lnot\\exists",
+    serialize: serializeQuantifier("\\lnot\\exists"),
     parse: parseQuantifier("NotExists")
   },
   {
@@ -10840,19 +10864,53 @@ var DEFINITIONS_LOGIC = [
       if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
       return ["Boole", body];
     }
+  },
+  // Predicate application in First-Order Logic.
+  // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
+  {
+    name: "Predicate",
+    serialize: (serializer, expr) => {
+      const args = operands(expr);
+      if (args.length === 0) return "";
+      const pred = args[0];
+      const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
+      if (args.length === 1) return predStr;
+      const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
+      return `${predStr}(${argStrs.join(", ")})`;
+    }
   }
 ];
+function serializeQuantifier(quantifierSymbol) {
+  return (serializer, expr) => {
+    const args = operands(expr);
+    if (args.length === 0) return quantifierSymbol;
+    if (args.length === 1)
+      return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
+    const boundVar = serializer.serialize(args[0]);
+    const body = serializer.serialize(args[1]);
+    return `${quantifierSymbol} ${boundVar}, ${body}`;
+  };
+}
+function tightBindingCondition(p, terminator) {
+  return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
+}
 function parseQuantifier(kind) {
   return (parser, terminator) => {
     const index = parser.index;
+    const useTightBinding = parser.options.quantifierScope !== "loose";
     const symbol2 = parser.parseSymbol(terminator);
     if (symbol2) {
       parser.skipSpace();
       if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-        const body2 = parser.parseExpression(terminator);
+        const bodyTerminator = useTightBinding ? { ...terminator, condition: (p) => tightBindingCondition(p, terminator) } : terminator;
+        parser.enterQuantifierScope();
+        const body2 = parser.parseExpression(bodyTerminator);
+        parser.exitQuantifierScope();
         return [kind, symbol2, missingIfEmpty(body2)];
       }
+      parser.enterQuantifierScope();
       const body = parser.parseEnclosure();
+      parser.exitQuantifierScope();
       if (body) return [kind, symbol2, missingIfEmpty(body)];
     }
     parser.index = index;
@@ -10860,11 +10918,16 @@ function parseQuantifier(kind) {
     if (condition === null) return null;
     parser.skipSpace();
     if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
-      const body = parser.parseExpression(terminator);
+      const bodyTerminator = useTightBinding ? { ...terminator, condition: (p) => tightBindingCondition(p, terminator) } : terminator;
+      parser.enterQuantifierScope();
+      const body = parser.parseExpression(bodyTerminator);
+      parser.exitQuantifierScope();
       return [kind, condition, missingIfEmpty(body)];
     }
     if (parser.match("(")) {
+      parser.enterQuantifierScope();
       const body = parser.parseExpression(terminator);
+      parser.exitQuantifierScope();
       if (!parser.match(")")) return null;
       return [kind, condition, missingIfEmpty(body)];
     }
@@ -11353,7 +11416,7 @@ function parseTrig(op) {
       "\\ch": "Cosh",
       // Non-standard
       "\\cos": "Cos",
-      "\\cosh": "Csch",
+      "\\cosh": "Cosh",
       "\\cosec": "Csc",
       // Non-standard
       "\\cot": "Cot",
@@ -13265,8 +13328,41 @@ function parseInvalidSymbol(parser) {
   return parser.error(["invalid-symbol", { str: validateSymbol(id) }], start);
 }
 function parseSymbol(parser) {
-  if (/^[a-zA-Z]$/.test(parser.peek) || /^\p{XIDS}$/u.test(parser.peek))
-    return parser.nextToken();
+  if (/^[a-zA-Z]$/.test(parser.peek) || /^\p{XIDS}$/u.test(parser.peek)) {
+    let id2 = parser.nextToken();
+    while (!parser.atEnd) {
+      const currentPeek = parser.peek;
+      if (currentPeek !== "_") break;
+      const underscoreIndex = parser.index;
+      parser.nextToken();
+      const hasBrace = parser.match("<{>");
+      if (hasBrace) {
+        const firstToken = parser.peek;
+        if (firstToken === "(" || firstToken === "\\lparen" || firstToken === "\\left") {
+          parser.index = underscoreIndex;
+          break;
+        }
+        const sub2 = parseSymbolBody(parser);
+        const hasOperators = sub2 !== null && /plus|minus|times|ast/.test(sub2);
+        if (sub2 === null || sub2.includes(",") || hasOperators || parser.peek !== "<}>") {
+          parser.index = underscoreIndex;
+          break;
+        }
+        parser.match("<}>");
+        id2 += "_" + sub2;
+      } else {
+        const subToken = parser.peek;
+        if (/^[a-zA-Z0-9]$/.test(subToken) || /^\p{XIDS}$/u.test(subToken)) {
+          parser.nextToken();
+          id2 += "_" + subToken;
+        } else {
+          parser.index = underscoreIndex;
+          break;
+        }
+      }
+    }
+    return id2;
+  }
   let id = matchPrefixedSymbol(parser);
   if (!id) {
     id = "";
@@ -13366,6 +13462,18 @@ var _Parser = class {
       throw new Error(`Symbol ${id} already declared as a different type`);
     this.symbolTable.ids[id] = type2;
   }
+  // Track whether we're inside a quantifier body (ForAll, Exists, etc.)
+  // When true, single uppercase letters followed by () are parsed as predicates
+  _quantifierScopeDepth = 0;
+  get inQuantifierScope() {
+    return this._quantifierScopeDepth > 0;
+  }
+  enterQuantifierScope() {
+    this._quantifierScopeDepth++;
+  }
+  exitQuantifierScope() {
+    if (this._quantifierScopeDepth > 0) this._quantifierScopeDepth--;
+  }
   get index() {
     return this._index;
   }
@@ -14251,9 +14359,10 @@ var _Parser = class {
       this.skipSpace();
       let body = this.parseExpression();
       this.skipSpace();
-      if (!this.matchBoundary()) {
-        const boundary = this._boundaries[this._boundaries.length - 1].tokens;
-        this.removeBoundary();
+      const boundary = this._boundaries[this._boundaries.length - 1]?.tokens;
+      const matchedBoundary = this.matchBoundary();
+      const sameTrigger = typeof def.openTrigger === "string" && typeof def.closeTrigger === "string" && def.openTrigger === def.closeTrigger || Array.isArray(def.openTrigger) && Array.isArray(def.closeTrigger) && def.openTrigger.length === def.closeTrigger.length && def.openTrigger.every((tok, i) => tok === def.closeTrigger[i]);
+      if (matchedBoundary && isEmptySequence(body) && sameTrigger && boundary) {
         this.index = bodyStart;
         this.skipSpace();
         body = this.parseExpression();
@@ -14263,6 +14372,18 @@ var _Parser = class {
           if (!this.atEnd) continue;
           return null;
         }
+      } else if (!matchedBoundary) {
+        const boundary2 = this._boundaries[this._boundaries.length - 1].tokens;
+        this.removeBoundary();
+        this.index = bodyStart;
+        this.skipSpace();
+        body = this.parseExpression();
+        this.skipSpace();
+        if (!this.matchAll(boundary2)) {
+          this.index = start;
+          if (!this.atEnd) continue;
+          return null;
+        }
       }
       const result = def.parse(this, body ?? "Nothing");
       if (result !== null) return result;
@@ -14311,12 +14432,16 @@ var _Parser = class {
         break;
       }
     }
+    let isPredicate = false;
     if (fn === null) {
       this.index = start;
       fn = parseSymbol(this);
       if (!this.isFunctionOperator(fn)) {
-        this.index = start;
-        return null;
+        if (!this.looksLikePredicate(fn)) {
+          this.index = start;
+          return null;
+        }
+        isPredicate = true;
       }
     }
     do {
@@ -14326,6 +14451,10 @@ var _Parser = class {
     } while (true);
     const args = this.parseArguments("enclosure", until);
     if (args === null) return fn;
+    if (isPredicate && typeof fn === "string") {
+      if (this.inQuantifierScope || fn === "D" || fn === "N")
+        return ["Predicate", fn, ...args];
+    }
     return typeof fn === "string" ? [fn, ...args] : ["Apply", fn, ...args];
   }
   parseSymbol(until) {
@@ -14714,9 +14843,24 @@ var _Parser = class {
   }
   isFunctionOperator(id) {
     if (id === null) return false;
+    if (id === "D" || id === "N") return false;
     if (this.getSymbolType(id).matches("function")) return true;
     return false;
   }
+  /**
+   * Check if a symbol looks like a predicate in First-Order Logic.
+   * A predicate is typically a single uppercase letter (P, Q, R, etc.)
+   * followed by parentheses containing arguments.
+   *
+   * This enables automatic inference of predicates without explicit declaration,
+   * so `\forall x. P(x)` works without having to declare `P` as a function.
+   */
+  looksLikePredicate(id) {
+    if (id === null || typeof id !== "string") return false;
+    if (!/^[A-Z]$/.test(id)) return false;
+    this.skipSpace();
+    return this.peek === "(" || this.peek === "\\left";
+  }
   /** Return all defs of the specified kind.
    * The defs at the end of the dictionary have priority, since they may
    * override previous definitions. (For example, there is a core definition
@@ -18599,7 +18743,10 @@ function polynomialDegree(expr, variable) {
   if (op === "Power") {
     const baseDeg = polynomialDegree(expr.op1, variable);
     if (baseDeg < 0) return -1;
-    if (baseDeg === 0) return 0;
+    if (baseDeg === 0) {
+      if (expr.op2.has(variable)) return -1;
+      return 0;
+    }
     const exp2 = asSmallInteger(expr.op2);
     if (exp2 === null || exp2 < 0) return -1;
     return baseDeg * exp2;
@@ -21638,8 +21785,6 @@ function canonicalLimits(ops, { engine: ce }) {
     }
     if (index.operator === "Hold") index = index.op1;
     if (!index.symbol) index = ce.typeError("symbol", index.type, index);
-    if (lower.symbol !== "Nothing") lower = checkType(ce, lower, "number");
-    if (upper.symbol !== "Nothing") upper = checkType(ce, upper, "number");
     return ce._fn("Limits", [index, lower, upper]);
   }
   return null;
@@ -22518,10 +22663,6 @@ function serializeScientificNotationNumber(valString, options, expMultiple = 1)
     fractionalPart = options.decimalSeparator + fractionalPart;
   wholePart = insertWholeGroupSeparator(wholePart, options);
   if (!expString) return wholePart + fractionalPart;
-  if (!fractionalPart) {
-    if (wholePart === "1") return expString;
-    if (wholePart === "-1") return "-" + expString;
-  }
   return wholePart + fractionalPart + options.exponentProduct + expString;
 }
 function serializeAutoNotationNumber(valString, options) {
@@ -23028,7 +23169,8 @@ var OPERATORS = {
   Negate: [
     (expr, serialize) => {
       const base = serialize(expr.op1, 14);
-      if (base === "Power") return `-(${base})`;
+      const op = expr.op1?.operator;
+      if (op === "Power" || op === "Square") return `-(${base})`;
       return `-${base}`;
     },
     14
@@ -23249,11 +23391,11 @@ function bigOp(expr, op, serialize) {
     const b = fn.op1 ?? fn;
     if (b.operator === "Block") body = serialize(b.op1 ?? b);
     else body = serialize(b);
-  } else if (fn?.symbol) {
+  } else if (fn) {
     args = [];
     body = serialize(fn);
   } else {
-    return "int()";
+    return `${op}()`;
   }
   let result = op;
   for (const limit2 of limits) {
@@ -25369,7 +25511,7 @@ var ARITHMETIC_LIBRARY = [
       description: "Rounds a number up to the next largest integer",
       complexity: 1250,
       broadcastable: true,
-      signature: "(real) -> integer",
+      signature: "(number) -> integer",
       sgn: ([x]) => {
         if (x.isLessEqual(-1)) return "negative";
         if (x.isPositive) return "positive";
@@ -26411,38 +26553,29 @@ var ARITHMETIC_LIBRARY = [
       signature: "((number+) -> number, (tuple<integer>|tuple<integer, integer>)+) -> number",
       canonical: ([body, ...bounds], { scope }) => canonicalBigop("Product", body, bounds, scope),
       evaluate: (ops, options) => {
-        const fn = (acc, x) => {
-          x = x.evaluate(options);
-          return x.isNumberLiteral ? acc.mul(x.numericValue) : null;
-        };
         const result = run(
           reduceBigOp(
             ops[0],
             ops.slice(1),
-            fn,
-            options.engine._numericValue(1)
+            (acc, x) => acc.mul(x.evaluate(options)),
+            options.engine.One
           ),
           options.engine._timeRemaining
         );
-        return options.engine.number(result ?? NaN);
+        return result?.evaluate() ?? options.engine.NaN;
       },
       evaluateAsync: async (ops, options) => {
-        const fn = (acc, x) => {
-          x = x.evaluate(options);
-          if (!x.isNumberLiteral) return null;
-          return acc.mul(x.numericValue);
-        };
         const result = await runAsync(
           reduceBigOp(
             ops[0],
             ops.slice(1),
-            fn,
-            options.engine._numericValue(1)
+            (acc, x) => acc.mul(x.evaluate(options)),
+            options.engine.One
           ),
           options.engine._timeRemaining,
           options.signal
         );
-        return options.engine.number(result ?? NaN);
+        return result?.evaluate() ?? options.engine.NaN;
       }
     },
     Sum: {
@@ -26454,36 +26587,31 @@ var ARITHMETIC_LIBRARY = [
       lazy: true,
       signature: "((number) -> number, bounds:tuple+) -> number",
       canonical: ([body, ...bounds], { scope }) => canonicalBigop("Sum", body, bounds, scope),
-      evaluate: ([fn, ...indexes], { engine }) => engine.number(
-        run(
+      evaluate: ([body, ...indexes], { engine }) => {
+        const result = run(
           reduceBigOp(
-            fn,
+            body,
             indexes,
-            (acc, x) => {
-              x = x.evaluate();
-              return x.isNumberLiteral ? acc.add(x.numericValue) : null;
-            },
-            engine._numericValue(0)
+            (acc, x) => acc.add(x.evaluate()),
+            engine.Zero
           ),
           engine._timeRemaining
-        )
-      ),
-      evaluateAsync: async (xs, { engine, signal }) => engine.number(
-        await runAsync(
+        );
+        return result?.evaluate() ?? engine.NaN;
+      },
+      evaluateAsync: async (xs, { engine, signal }) => {
+        const result = await runAsync(
           reduceBigOp(
             xs[0],
             xs.slice(1),
-            (acc, x) => {
-              x = x.evaluate();
-              if (!x.isNumberLiteral) return null;
-              return acc.add(x.numericValue);
-            },
-            engine._numericValue(0)
+            (acc, x) => acc.add(x.evaluate()),
+            engine.Zero
           ),
           engine._timeRemaining,
           signal
-        )
-      )
+        );
+        return result?.evaluate() ?? engine.NaN;
+      }
     }
   }
 ];
@@ -26673,17 +26801,12 @@ var DERIVATIVES_TABLE = {
   Ln: ["Divide", 1, "_"],
   Log: ["Power", ["Multiply", "_", ["Ln", "10"]], -1],
   Sqrt: ["Multiply", ["Power", "_", ["Negate", "Half"]], "Half"],
-  Abs: [
-    "Which",
-    ["Equal", "_", 0],
-    NaN,
-    ["Less", "_", 0],
-    -1,
-    ["Greater", "_", 0],
-    1,
-    "True",
-    ["D", ["Abs", "_"], "_"]
-  ],
+  // d/dx |x| = x/|x| = sign(x) for x ≠ 0 (undefined at x = 0)
+  Abs: ["Sign", "_"],
+  // Step functions: derivative is 0 almost everywhere (undefined at discontinuities)
+  Floor: 0,
+  Ceil: 0,
+  Round: 0,
   // https://proofwiki.org/wiki/Derivative_of_Error_Function
   Erf: [
     "Multiply",
@@ -26692,51 +26815,36 @@ var DERIVATIVES_TABLE = {
   ],
   // https://proofwiki.org/wiki/Derivative_of_Gamma_Function
   // https://en.wikipedia.org/wiki/Gamma_function
+  // d/dx Γ(x) = Γ(x)·ψ(x) where ψ is the digamma function
   Gamma: ["Multiply", ["Gamma", "_"], ["Digamma", "_"]],
-  Digamma: [
-    "Add",
-    ["Multiply", ["Digamma", "_"], ["Gamma", "_"]],
-    ["Multiply", ["Power", "_", -1], ["Gamma", "_"]]
-  ],
-  Zeta: ["Multiply", ["Multiply", -1, ["Zeta", "_"]], ["Digamma", "_"]],
-  PolyGamma: [
-    "Add",
-    ["Multiply", ["PolyGamma", "_"], ["Gamma", "_"]],
-    ["Multiply", ["Power", "_", -1], ["Gamma", "_"]]
-  ],
-  Beta: [
-    "Multiply",
-    [
-      "Add",
-      ["Multiply", ["Beta", "_"], ["Digamma", "_"]],
-      ["Multiply", ["Power", "_", -1], ["Beta", "_"]]
-    ],
-    ["Beta", "_"]
-  ],
+  // d/dx erfc(x) = -d/dx erf(x) = -2/√π * e^(-x²)
   Erfc: [
-    "Multiply",
-    ["Negate", ["Erfc", "_"]],
-    ["Exp", ["Negate", ["Power", "_", 2]]],
-    ["Power", "_", -1]
+    "Negate",
+    ["Multiply", ["Divide", 2, ["Sqrt", "Pi"]], ["Exp", ["Negate", ["Square", "_"]]]]
   ],
-  LambertW: [
+  // d/dx ln(Γ(x)) = ψ(x) (digamma function)
+  LogGamma: ["Digamma", "_"],
+  // Note: LambertW derivative d/dx W(x) = W(x)/(x·(1+W(x))) is mathematically correct
+  // but omitted because LambertW lacks a type signature, causing type errors.
+  //
+  // d/dx S(x) = sin(πx²/2) where S is the Fresnel sine integral
+  FresnelS: ["Sin", ["Multiply", ["Divide", "Pi", 2], ["Square", "_"]]],
+  // d/dx C(x) = cos(πx²/2) where C is the Fresnel cosine integral
+  FresnelC: ["Cos", ["Multiply", ["Divide", "Pi", 2], ["Square", "_"]]],
+  // d/dx erfi(x) = (2/√π)·e^(x²) where erfi is the imaginary error function
+  Erfi: [
     "Multiply",
-    ["Power", "_", -1],
-    [
-      "Multiply",
-      ["Add", "_", ["LambertW", "_"]],
-      ["Add", ["LambertW", "_"], 1]
-    ]
-  ],
-  AiryAi: ["Multiply", ["AiryAi", "_"], ["AiryBi", "_"]],
-  AiryBi: ["Multiply", ["AiryAi", "_"], ["AiryBi", "_"]],
-  BesselJ: ["Multiply", ["BesselJ", "_"], ["BesselY", "_"]],
-  BesselY: ["Multiply", ["BesselJ", "_"], ["BesselY", "_"]],
-  BesselI: ["Multiply", ["BesselI", "_"], ["BesselK", "_"]],
-  BesselK: ["Multiply", ["BesselI", "_"], ["BesselK", "_"]],
-  FresnelS: ["Multiply", ["FresnelS", "_"], ["FresnelC", "_"]],
-  FresnelC: ["Multiply", ["FresnelS", "_"], ["FresnelC", "_"]],
-  Erfi: ["Multiply", ["Erfi", "_"], ["Erf", "_"]]
+    ["Divide", 2, ["Sqrt", "Pi"]],
+    ["Exp", ["Square", "_"]]
+  ]
+  // Note: Bessel functions (BesselJ, BesselY, BesselI, BesselK) and Airy functions
+  // (AiryAi, AiryBi) have been omitted because their derivatives involve functions
+  // of different orders or related derivative functions that are not in the standard
+  // function set. For example, d/dx J_n(x) = (J_{n-1}(x) - J_{n+1}(x))/2.
+  //
+  // Similarly, Zeta, Digamma, PolyGamma, and Beta derivatives are omitted because
+  // they either don't have simple closed forms or involve additional functions not
+  // in the standard set (trigamma function, etc.).
 };
 function derivative(fn, order2) {
   if (order2 === 0) return fn;
@@ -26789,6 +26897,15 @@ function differentiate(expr, v) {
     if (terms.some((term) => term === void 0)) return void 0;
     return simplifyDerivative(add3(...terms));
   }
+  if (expr.operator === "Root") {
+    const [base, n] = expr.ops;
+    if (!base.has(v)) return ce.Zero;
+    const exponent = ce.One.div(n);
+    const basePrime = differentiate(base, v) ?? ce._fn("D", [base, ce.symbol(v)]);
+    const newExponent = exponent.sub(ce.One);
+    const power = ce.function("Power", [base, newExponent], { structural: true });
+    return simplifyDerivative(exponent.mul(power).mul(basePrime));
+  }
   if (expr.operator === "Power") {
     const [base, exponent] = expr.ops;
     const baseHasV = base.has(v);
@@ -26825,7 +26942,7 @@ function differentiate(expr, v) {
     );
   }
   const h = DERIVATIVES_TABLE[expr.operator];
-  if (!h) {
+  if (h === void 0) {
     if (expr.nops > 1) return void 0;
     const fPrime = ce._fn("Derivative", [ce.symbol(expr.operator), ce.One]);
     if (!fPrime.isValid) return void 0;
@@ -27406,6 +27523,14 @@ var UNIVARIATE_ROOTS = [
     // Handle ax = 0
     condition: filter
   },
+  // -ax + b = 0  =>  x = b/a
+  // This handles cases where the coefficient is negative and represented as Negate(Multiply(...))
+  {
+    match: ["Add", ["Negate", ["Multiply", "_x", "__a"]], "__b"],
+    replace: ["Divide", "__b", "__a"],
+    useVariations: true,
+    condition: filter
+  },
   // ax^n + b = 0
   {
     match: ["Add", ["Multiply", "_a", ["Power", "_x", "_n"]], "__b"],
@@ -27541,27 +27666,140 @@ var UNIVARIATE_ROOTS = [
     replace: ["Divide", ["Negate", ["Add", "__b", "__c"], "__a"]],
     condition: filter
   },
-  // ax + c\sqrt{dx + f} + g = 0
-  // plus
+  //
+  // Square root equations: ax + b√x + c = 0
+  // Using substitution u = √x, this becomes au² + bu + c = 0
+  // Solving: u = (-b ± √(b² - 4ac)) / 2a
+  // Then x = u² = ((-b ± √(b² - 4ac)) / 2a)²
+  //
+  // ax + b√x + c = 0 (plus root)
+  {
+    match: ["Add", ["Multiply", "_x", "__a"], ["Multiply", "__b", ["Sqrt", "_x"]], "___c"],
+    replace: [
+      "Power",
+      [
+        "Divide",
+        ["Add", ["Negate", "__b"], ["Sqrt", ["Subtract", ["Square", "__b"], ["Multiply", 4, "__a", "___c"]]]],
+        ["Multiply", 2, "__a"]
+      ],
+      2
+    ],
+    useVariations: true,
+    condition: filter
+  },
+  // ax + b√x + c = 0 (minus root)
+  {
+    match: ["Add", ["Multiply", "_x", "__a"], ["Multiply", "__b", ["Sqrt", "_x"]], "___c"],
+    replace: [
+      "Power",
+      [
+        "Divide",
+        ["Subtract", ["Negate", "__b"], ["Sqrt", ["Subtract", ["Square", "__b"], ["Multiply", 4, "__a", "___c"]]]],
+        ["Multiply", 2, "__a"]
+      ],
+      2
+    ],
+    useVariations: true,
+    condition: filter
+  },
+  // Handle negated coefficient: ax - b√x + c = 0
+  // This handles the Negate(Multiply(...)) pattern
+  {
+    match: ["Add", ["Multiply", "_x", "__a"], ["Negate", ["Multiply", "__b", ["Sqrt", "_x"]]], "___c"],
+    replace: [
+      "Power",
+      [
+        "Divide",
+        ["Add", "__b", ["Sqrt", ["Add", ["Square", "__b"], ["Multiply", 4, "__a", "___c"]]]],
+        ["Multiply", 2, "__a"]
+      ],
+      2
+    ],
+    useVariations: true,
+    condition: filter
+  },
+  // ax - b√x + c = 0 (minus root)
+  {
+    match: ["Add", ["Multiply", "_x", "__a"], ["Negate", ["Multiply", "__b", ["Sqrt", "_x"]]], "___c"],
+    replace: [
+      "Power",
+      [
+        "Divide",
+        ["Subtract", "__b", ["Sqrt", ["Add", ["Square", "__b"], ["Multiply", 4, "__a", "___c"]]]],
+        ["Multiply", 2, "__a"]
+      ],
+      2
+    ],
+    useVariations: true,
+    condition: filter
+  },
+  //
+  // Additional solve rules
+  //
+  // a√x + b = 0  =>  x = (b/a)² (only valid when -b/a ≥ 0)
+  {
+    match: ["Add", ["Multiply", "__a", ["Sqrt", "_x"]], "__b"],
+    replace: ["Square", ["Divide", ["Negate", "__b"], "__a"]],
+    useVariations: true,
+    condition: (sub2) => {
+      if (!filter(sub2)) return false;
+      const a = sub2.__a;
+      const b = sub2.__b;
+      if (!a || !b) return false;
+      const ratio = b.div(a);
+      return ratio.isNonPositive ?? true;
+    }
+  },
+  // a·ln(x) + b = 0  =>  x = e^(-b/a)
   {
-    match: "ax + \\mathrm{__b} \\sqrt{cx + \\mathrm{__d}} + \\mathrm{__g}",
-    replace: "\\frac{-(2 a g - \\mathrm{__b}^2 c) + \\sqrt{(2 a \\mathrm{__g} - \\mathrm{__b}^2 c)^2 - 4 a^2(g^2 - b^2 \\mathrm{__d})}}{2 a^2}",
+    match: ["Add", ["Multiply", "__a", ["Ln", "_x"]], "__b"],
+    replace: ["Exp", ["Divide", ["Negate", "__b"], "__a"]],
     useVariations: true,
     condition: filter
   },
-  // minus
+  // ln(x) + b = 0  =>  x = e^(-b)
   {
-    match: "ax + \\mathrm{__b} \\sqrt{cx + \\mathrm{__d}} + \\mathrm{__g}",
-    replace: "\\frac{-(2 a g - \\mathrm{__b}^2 c) - \\sqrt{(2 a \\mathrm{__g} - \\mathrm{__b}^2 c)^2 - 4 a^2(g^2 - b^2 \\mathrm{__d})}}{2 a^2}",
+    match: ["Add", ["Ln", "_x"], "__b"],
+    replace: ["Exp", ["Negate", "__b"]],
     useVariations: true,
     condition: filter
   }
 ];
+function clearDenominators(expr, variable) {
+  if (expr.operator !== "Add") return expr;
+  const ops = expr.ops;
+  if (!ops || ops.length === 0) return expr;
+  const denominators = ops.map((op) => op.denominator).filter((d) => !d.is(1));
+  if (denominators.length === 0) return expr;
+  const lcmFactors = [];
+  for (const denom of denominators) {
+    let isDuplicate = false;
+    for (const existing of lcmFactors) {
+      if (denom.isSame(existing)) {
+        isDuplicate = true;
+        break;
+      }
+      if (denom.symbol && existing.symbol && denom.symbol === existing.symbol) {
+        isDuplicate = true;
+        break;
+      }
+    }
+    if (!isDuplicate) {
+      lcmFactors.push(denom);
+    }
+  }
+  let lcm4 = lcmFactors[0];
+  for (let i = 1; i < lcmFactors.length; i++) {
+    lcm4 = lcm4.mul(lcmFactors[i]);
+  }
+  return expr.mul(lcm4).simplify();
+}
 function findUnivariateRoots(expr, x) {
   const ce = expr.engine;
   if (expr.operator === "Equal")
     expr = expr.op1.expand().sub(expr.op2.expand()).simplify();
   else expr = expr.expand().simplify();
+  expr = clearDenominators(expr);
   const rules = ce.getRuleSet("solve-univariate");
   let exprs = [expr.subs({ [x]: "_x" }, { canonical: false })];
   ce.pushScope();
@@ -28423,40 +28661,46 @@ var INTEGRATION_RULES = [
     ],
     condition: filter2
   },
-  // \arctan(ax + b) -> \frac{1}{a} \ln(\sec(ax + b) + \tan(ax + b))
+  // \arctan(ax + b) -> (1/a) * [(ax+b)*arctan(ax+b) - (1/2)*ln(1+(ax+b)^2)]
   {
     match: ["Arctan", ["Add", ["Multiply", "_a", "_x"], "__b"]],
     replace: [
       "Divide",
       [
-        "Ln",
+        "Subtract",
         [
-          "Add",
-          ["Sec", ["Add", ["Multiply", "_a", "_x"], "__b"]],
-          ["Tan", ["Add", ["Multiply", "_a", "_x"], "__b"]]
+          "Multiply",
+          ["Add", ["Multiply", "_a", "_x"], "__b"],
+          ["Arctan", ["Add", ["Multiply", "_a", "_x"], "__b"]]
+        ],
+        [
+          "Multiply",
+          ["Rational", 1, 2],
+          ["Ln", ["Add", 1, ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 2]]]
         ]
       ],
       "_a"
     ],
     condition: filter2
   },
-  // \arccos(ax + b) -> \frac{1}{a} \ln(ax + b + \sqrt{(ax + b)^2 - 1})
+  // \arccos(ax + b) -> (1/a) * [(ax+b)*arccos(ax+b) - sqrt(1-(ax+b)^2)]
   {
     match: ["Arccos", ["Add", ["Multiply", "_a", "_x"], "__b"]],
     replace: [
       "Divide",
       [
-        "Ln",
+        "Subtract",
         [
-          "Add",
+          "Multiply",
           ["Add", ["Multiply", "_a", "_x"], "__b"],
+          ["Arccos", ["Add", ["Multiply", "_a", "_x"], "__b"]]
+        ],
+        [
+          "Sqrt",
           [
-            "Sqrt",
-            [
-              "Subtract",
-              ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 2],
-              1
-            ]
+            "Subtract",
+            1,
+            ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 2]
           ]
         ]
       ],
@@ -28464,23 +28708,24 @@ var INTEGRATION_RULES = [
     ],
     condition: filter2
   },
-  // \arcsin(ax + b) -> \frac{1}{a} \ln(ax + b + \sqrt{1 - (ax + b)^2})
+  // \arcsin(ax + b) -> (1/a) * [(ax+b)*arcsin(ax+b) + sqrt(1-(ax+b)^2)]
   {
     match: ["Arcsin", ["Add", ["Multiply", "_a", "_x"], "__b"]],
     replace: [
       "Divide",
       [
-        "Ln",
+        "Add",
         [
-          "Add",
+          "Multiply",
           ["Add", ["Multiply", "_a", "_x"], "__b"],
+          ["Arcsin", ["Add", ["Multiply", "_a", "_x"], "__b"]]
+        ],
+        [
+          "Sqrt",
           [
-            "Sqrt",
-            [
-              "Subtract",
-              1,
-              ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 2]
-            ]
+            "Subtract",
+            1,
+            ["Power", ["Add", ["Multiply", "_a", "_x"], "__b"], 2]
           ]
         ]
       ],
@@ -29294,6 +29539,8 @@ var CALCULUS_LIBRARY = [
         }
         f = f?.canonical;
         if (f?.operator === "D") return f;
+        if (f?.operator === "Apply" && f.op1?.operator === "Derivative")
+          return f;
         if (f && hasSymbolicTranscendental(f)) return f;
         return f?.evaluate();
       }
@@ -29420,7 +29667,7 @@ var CALCULUS_LIBRARY = [
       complexity: 5e3,
       broadcastable: false,
       lazy: true,
-      signature: "(index:symbol, lower:number, upper:number) -> tuple",
+      signature: "(index:symbol, lower:value, upper:value) -> tuple",
       canonical: (ops, { engine }) => canonicalLimits(ops, { engine }) ?? null
     }
   },
@@ -30933,12 +31180,22 @@ var CORE_LIBRARY = [
         }
         if (op1.isIndexedCollection) return ce._fn("At", [op1, op2.canonical]);
         if (op1.symbol) {
-          const sub2 = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
-          if (sub2) return ce.symbol(op1.symbol + "_" + sub2);
+          const sub3 = op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
+          if (sub3) return ce.symbol(op1.symbol + "_" + sub3);
+          if (op2.operator === "InvisibleOperator" && op2.ops) {
+            const parts = op2.ops.map(
+              (x) => x.symbol ?? asSmallInteger(x)?.toString()
+            );
+            if (parts.every((p) => p !== void 0 && p !== null)) {
+              return ce.symbol(op1.symbol + "_" + parts.join(""));
+            }
+          }
         }
         if (op2.operator === "Sequence")
           ce._fn("Subscript", [op1, ce._fn("List", op2.ops)]);
-        return ce._fn("Subscript", [op1, op2]);
+        let sub2 = op2;
+        if (op2.operator === "Delimiter" && op2.op1) sub2 = op2.op1.canonical;
+        return ce._fn("Subscript", [op1, sub2]);
       }
     },
     Symbol: {
@@ -32668,6 +32925,539 @@ function canonicalMatrix(ops, { engine: ce }) {
   return ce._fn(operator2, [body]);
 }
 
+// src/compute-engine/library/logic-utils.ts
+function evaluateAnd(args, { engine: ce }) {
+  if (args.length === 0) return ce.True;
+  const ops = [];
+  for (const arg of args) {
+    if (arg.symbol === "False") return ce.False;
+    if (arg.symbol !== "True") {
+      let duplicate = false;
+      for (const x of ops) {
+        if (x.isSame(arg)) {
+          duplicate = true;
+        } else if (arg.operator === "Not" && arg.op1.isSame(x) || x.operator === "Not" && x.op1.isSame(arg)) {
+          return ce.False;
+        }
+      }
+      if (!duplicate) ops.push(arg);
+    }
+  }
+  if (ops.length === 0) return ce.True;
+  if (ops.length === 1) return ops[0];
+  return ce._fn("And", ops);
+}
+function evaluateOr(args, { engine: ce }) {
+  if (args.length === 0) return ce.True;
+  const ops = [];
+  for (const arg of args) {
+    if (arg.symbol === "True") return ce.True;
+    if (arg.symbol !== "False") {
+      let duplicate = false;
+      for (const x of ops) {
+        if (x.isSame(arg)) {
+          duplicate = true;
+        } else if (arg.operator === "Not" && arg.op1.isSame(x) || x.operator === "Not" && x.op1.isSame(arg)) {
+          return ce.True;
+        }
+      }
+      if (!duplicate) ops.push(arg);
+    }
+  }
+  if (ops.length === 0) return ce.False;
+  if (ops.length === 1) return ops[0];
+  return ce._fn("Or", ops);
+}
+function evaluateNot(args, { engine: ce }) {
+  const op1 = args[0]?.symbol;
+  if (op1 === "True") return ce.False;
+  if (op1 === "False") return ce.True;
+  return void 0;
+}
+function evaluateEquivalent(args, { engine: ce }) {
+  const lhs = args[0].symbol;
+  const rhs = args[1].symbol;
+  if (lhs === "True" && rhs === "True" || lhs === "False" && rhs === "False")
+    return ce.True;
+  if (lhs === "True" && rhs === "False" || lhs === "False" && rhs === "True")
+    return ce.False;
+  return void 0;
+}
+function evaluateImplies(args, { engine: ce }) {
+  const lhs = args[0].symbol;
+  const rhs = args[1].symbol;
+  if (lhs === "True" && rhs === "True" || lhs === "False" && rhs === "False" || lhs === "False" && rhs === "True")
+    return ce.True;
+  if (lhs === "True" && rhs === "False") return ce.False;
+  return void 0;
+}
+function evaluateXor(args, { engine: ce }) {
+  if (args.length === 0) return ce.False;
+  let trueCount = 0;
+  const unknowns = [];
+  for (const arg of args) {
+    if (arg.symbol === "True") {
+      trueCount++;
+    } else if (arg.symbol === "False") {
+    } else {
+      unknowns.push(arg);
+    }
+  }
+  if (unknowns.length === 0) {
+    return trueCount % 2 === 1 ? ce.True : ce.False;
+  }
+  if (unknowns.length === 1 && trueCount % 2 === 1) {
+    return ce._fn("Not", [unknowns[0]]);
+  }
+  if (unknowns.length === 1 && trueCount % 2 === 0) {
+    return unknowns[0];
+  }
+  return void 0;
+}
+function evaluateNand(args, { engine: ce }) {
+  if (args.length === 0) return ce.False;
+  for (const arg of args) {
+    if (arg.symbol === "False") return ce.True;
+  }
+  let allTrue = true;
+  for (const arg of args) {
+    if (arg.symbol !== "True") {
+      allTrue = false;
+      break;
+    }
+  }
+  if (allTrue) return ce.False;
+  return void 0;
+}
+function evaluateNor(args, { engine: ce }) {
+  if (args.length === 0) return ce.True;
+  for (const arg of args) {
+    if (arg.symbol === "True") return ce.False;
+  }
+  let allFalse = true;
+  for (const arg of args) {
+    if (arg.symbol !== "False") {
+      allFalse = false;
+      break;
+    }
+  }
+  if (allFalse) return ce.True;
+  return void 0;
+}
+function toNNF(expr, ce) {
+  const op = expr.operator;
+  if (!op) return expr;
+  if (expr.symbol === "True" || expr.symbol === "False") return expr;
+  if (op === "Not") {
+    const inner = expr.op1;
+    if (!inner) return expr;
+    const innerOp = inner.operator;
+    if (innerOp === "Not") {
+      return toNNF(inner.op1, ce);
+    }
+    if (innerOp === "And") {
+      const negatedOps = inner.ops.map((x) => toNNF(ce._fn("Not", [x]), ce));
+      return ce._fn("Or", negatedOps);
+    }
+    if (innerOp === "Or") {
+      const negatedOps = inner.ops.map((x) => toNNF(ce._fn("Not", [x]), ce));
+      return ce._fn("And", negatedOps);
+    }
+    if (inner.symbol === "True") return ce.False;
+    if (inner.symbol === "False") return ce.True;
+    if (innerOp === "Implies") {
+      const a = inner.op1;
+      const b = inner.op2;
+      return toNNF(ce._fn("And", [a, ce._fn("Not", [b])]), ce);
+    }
+    if (innerOp === "Equivalent") {
+      const a = inner.op1;
+      const b = inner.op2;
+      return toNNF(
+        ce._fn("Or", [
+          ce._fn("And", [a, ce._fn("Not", [b])]),
+          ce._fn("And", [ce._fn("Not", [a]), b])
+        ]),
+        ce
+      );
+    }
+    if (innerOp === "Xor") {
+      const ops = inner.ops;
+      if (ops.length === 2) {
+        const a = ops[0];
+        const b = ops[1];
+        return toNNF(
+          ce._fn("Or", [
+            ce._fn("And", [a, b]),
+            ce._fn("And", [ce._fn("Not", [a]), ce._fn("Not", [b])])
+          ]),
+          ce
+        );
+      }
+      return toNNF(ce._fn("Not", [toNNF(inner, ce)]), ce);
+    }
+    if (innerOp === "Nand") {
+      return toNNF(ce._fn("And", inner.ops), ce);
+    }
+    if (innerOp === "Nor") {
+      return toNNF(ce._fn("Or", inner.ops), ce);
+    }
+    return expr;
+  }
+  if (op === "Implies") {
+    const a = expr.op1;
+    const b = expr.op2;
+    return toNNF(ce._fn("Or", [ce._fn("Not", [a]), b]), ce);
+  }
+  if (op === "Equivalent") {
+    const a = expr.op1;
+    const b = expr.op2;
+    return toNNF(
+      ce._fn("And", [
+        ce._fn("Or", [ce._fn("Not", [a]), b]),
+        ce._fn("Or", [ce._fn("Not", [b]), a])
+      ]),
+      ce
+    );
+  }
+  if (op === "Xor") {
+    const ops = expr.ops;
+    if (ops.length === 2) {
+      const a = ops[0];
+      const b = ops[1];
+      return toNNF(
+        ce._fn("And", [
+          ce._fn("Or", [a, b]),
+          ce._fn("Or", [ce._fn("Not", [a]), ce._fn("Not", [b])])
+        ]),
+        ce
+      );
+    }
+    if (ops.length > 2) {
+      const first = ce._fn("Xor", [ops[0], ops[1]]);
+      const rest = ops.slice(2);
+      return toNNF(ce._fn("Xor", [first, ...rest]), ce);
+    }
+    if (ops.length === 1) return toNNF(ops[0], ce);
+    return ce.False;
+  }
+  if (op === "Nand") {
+    const ops = expr.ops;
+    return toNNF(ce._fn("Not", [ce._fn("And", ops)]), ce);
+  }
+  if (op === "Nor") {
+    const ops = expr.ops;
+    return toNNF(ce._fn("Not", [ce._fn("Or", ops)]), ce);
+  }
+  if (op === "And" || op === "Or") {
+    const nnfOps = expr.ops.map((x) => toNNF(x, ce));
+    return ce._fn(op, nnfOps);
+  }
+  return expr;
+}
+function distributeOrOverAnd(expr, ce) {
+  const op = expr.operator;
+  if (op !== "Or") {
+    if (op === "And") {
+      return ce._fn(
+        "And",
+        expr.ops.map((x) => distributeOrOverAnd(x, ce))
+      );
+    }
+    return expr;
+  }
+  const orOperands = [];
+  for (const operand2 of expr.ops) {
+    if (operand2.operator === "Or") {
+      orOperands.push(...operand2.ops);
+    } else {
+      orOperands.push(operand2);
+    }
+  }
+  const andIndex = orOperands.findIndex((x) => x.operator === "And");
+  if (andIndex === -1) {
+    return expr;
+  }
+  const andExpr = orOperands[andIndex];
+  const otherOperands = [
+    ...orOperands.slice(0, andIndex),
+    ...orOperands.slice(andIndex + 1)
+  ];
+  const otherOr = otherOperands.length === 1 ? otherOperands[0] : ce._fn("Or", otherOperands);
+  const distributed = ce._fn(
+    "And",
+    andExpr.ops.map((x) => ce._fn("Or", [x, otherOr]))
+  );
+  return distributeOrOverAnd(distributed, ce);
+}
+function toCNF(expr, ce) {
+  const nnf = toNNF(expr, ce);
+  const cnf = distributeOrOverAnd(nnf, ce);
+  return cnf.simplify();
+}
+function distributeAndOverOr(expr, ce) {
+  const op = expr.operator;
+  if (op !== "And") {
+    if (op === "Or") {
+      return ce._fn(
+        "Or",
+        expr.ops.map((x) => distributeAndOverOr(x, ce))
+      );
+    }
+    return expr;
+  }
+  const andOperands = [];
+  for (const operand2 of expr.ops) {
+    if (operand2.operator === "And") {
+      andOperands.push(...operand2.ops);
+    } else {
+      andOperands.push(operand2);
+    }
+  }
+  const orIndex = andOperands.findIndex((x) => x.operator === "Or");
+  if (orIndex === -1) {
+    return expr;
+  }
+  const orExpr = andOperands[orIndex];
+  const otherOperands = [
+    ...andOperands.slice(0, orIndex),
+    ...andOperands.slice(orIndex + 1)
+  ];
+  const otherAnd = otherOperands.length === 1 ? otherOperands[0] : ce._fn("And", otherOperands);
+  const distributed = ce._fn(
+    "Or",
+    orExpr.ops.map((x) => ce._fn("And", [x, otherAnd]))
+  );
+  return distributeAndOverOr(distributed, ce);
+}
+function toDNF(expr, ce) {
+  const nnf = toNNF(expr, ce);
+  const dnf = distributeAndOverOr(nnf, ce);
+  return dnf.simplify();
+}
+function extractVariables(expr) {
+  const variables = /* @__PURE__ */ new Set();
+  function visit(e) {
+    if (e.symbol === "True" || e.symbol === "False") return;
+    if (e.symbol && e.operator === "Symbol") {
+      variables.add(e.symbol);
+      return;
+    }
+    if (e.ops) {
+      for (const op of e.ops) {
+        visit(op);
+      }
+    }
+  }
+  visit(expr);
+  return Array.from(variables).sort();
+}
+function evaluateWithAssignment(expr, assignment, ce) {
+  const subs = {};
+  for (const [variable, value] of Object.entries(assignment)) {
+    subs[variable] = value ? ce.True : ce.False;
+  }
+  const substituted = expr.subs(subs).canonical;
+  return substituted.evaluate();
+}
+function* generateAssignments(variables) {
+  const n = variables.length;
+  const total = 1 << n;
+  for (let i = 0; i < total; i++) {
+    const assignment = {};
+    for (let j = 0; j < n; j++) {
+      assignment[variables[j]] = (i >> n - 1 - j & 1) === 1;
+    }
+    yield assignment;
+  }
+}
+
+// src/compute-engine/library/logic-analysis.ts
+function extractFiniteDomain(condition, ce) {
+  if (condition.operator !== "Element") return null;
+  const variable = condition.op1?.symbol;
+  if (!variable) return null;
+  const domain = condition.op2;
+  if (!domain) return null;
+  if (domain.operator === "Set" || domain.operator === "List") {
+    const values = domain.ops;
+    if (values && values.length <= 1e3) {
+      return { variable, values: [...values] };
+    }
+    return null;
+  }
+  if (domain.operator === "Range") {
+    const start = asSmallInteger(domain.op1);
+    const end = asSmallInteger(domain.op2);
+    const step = domain.ops && domain.ops.length >= 3 ? asSmallInteger(domain.op3) : 1;
+    if (start !== null && end !== null && step !== null && step !== 0) {
+      const count = Math.floor((end - start) / step) + 1;
+      if (count > 0 && count <= 1e3) {
+        const values = [];
+        for (let i = start; step > 0 ? i <= end : i >= end; i += step) {
+          values.push(ce.number(i));
+        }
+        return { variable, values };
+      }
+    }
+    return null;
+  }
+  if (domain.operator === "Interval") {
+    const start = asSmallInteger(domain.op1);
+    const end = asSmallInteger(domain.op2);
+    if (start !== null && end !== null) {
+      const count = end - start + 1;
+      if (count > 0 && count <= 1e3) {
+        const values = [];
+        for (let i = start; i <= end; i++) {
+          values.push(ce.number(i));
+        }
+        return { variable, values };
+      }
+    }
+    return null;
+  }
+  return null;
+}
+function bodyContainsVariable(expr, variable) {
+  if (expr.symbol === variable) return true;
+  if (expr.ops) {
+    for (const op of expr.ops) {
+      if (bodyContainsVariable(op, variable)) return true;
+    }
+  }
+  return false;
+}
+function collectNestedDomains(body, ce) {
+  const canonicalBody = body.canonical;
+  const op = canonicalBody.operator;
+  if (op !== "ForAll" && op !== "Exists") return [];
+  const condition = canonicalBody.op1;
+  const innerBody = canonicalBody.op2;
+  if (!condition || !innerBody) return [];
+  const domain = extractFiniteDomain(condition, ce);
+  if (!domain) return [];
+  const innerDomains = collectNestedDomains(innerBody, ce);
+  return [{ variable: domain.variable, values: domain.values }, ...innerDomains];
+}
+function getInnermostBody(body) {
+  const canonicalBody = body.canonical;
+  const op = canonicalBody.operator;
+  if (op === "ForAll" || op === "Exists") {
+    const innerBody = canonicalBody.op2;
+    if (innerBody) return getInnermostBody(innerBody);
+  }
+  return canonicalBody;
+}
+function evaluateForAllCartesian(domains, body, ce) {
+  const indices = domains.map(() => 0);
+  const lengths = domains.map((d) => d.values.length);
+  if (lengths.some((l) => l === 0)) return ce.True;
+  while (true) {
+    const subs = {};
+    for (let i = 0; i < domains.length; i++) {
+      subs[domains[i].variable] = domains[i].values[indices[i]];
+    }
+    const substituted = body.subs(subs).canonical;
+    const result = substituted.evaluate();
+    if (result.symbol === "False") {
+      return ce.False;
+    }
+    if (result.symbol !== "True") {
+      return void 0;
+    }
+    let dim = domains.length - 1;
+    while (dim >= 0) {
+      indices[dim]++;
+      if (indices[dim] < lengths[dim]) break;
+      indices[dim] = 0;
+      dim--;
+    }
+    if (dim < 0) break;
+  }
+  return ce.True;
+}
+function evaluateExistsCartesian(domains, body, ce) {
+  const indices = domains.map(() => 0);
+  const lengths = domains.map((d) => d.values.length);
+  if (lengths.some((l) => l === 0)) return ce.False;
+  while (true) {
+    const subs = {};
+    for (let i = 0; i < domains.length; i++) {
+      subs[domains[i].variable] = domains[i].values[indices[i]];
+    }
+    const substituted = body.subs(subs).canonical;
+    const result = substituted.evaluate();
+    if (result.symbol === "True") {
+      return ce.True;
+    }
+    let dim = domains.length - 1;
+    while (dim >= 0) {
+      indices[dim]++;
+      if (indices[dim] < lengths[dim]) break;
+      indices[dim] = 0;
+      dim--;
+    }
+    if (dim < 0) break;
+  }
+  return ce.False;
+}
+function isSatisfiable(expr, ce) {
+  const variables = extractVariables(expr);
+  if (variables.length === 0) {
+    const result = expr.evaluate();
+    return result.symbol === "True" ? ce.True : ce.False;
+  }
+  if (variables.length > 20) {
+    return ce._fn("IsSatisfiable", [expr]);
+  }
+  for (const assignment of generateAssignments(variables)) {
+    const result = evaluateWithAssignment(expr, assignment, ce);
+    if (result.symbol === "True") {
+      return ce.True;
+    }
+  }
+  return ce.False;
+}
+function isTautology(expr, ce) {
+  const variables = extractVariables(expr);
+  if (variables.length === 0) {
+    const result = expr.evaluate();
+    return result.symbol === "True" ? ce.True : ce.False;
+  }
+  if (variables.length > 20) {
+    return ce._fn("IsTautology", [expr]);
+  }
+  for (const assignment of generateAssignments(variables)) {
+    const result = evaluateWithAssignment(expr, assignment, ce);
+    if (result.symbol !== "True") {
+      return ce.False;
+    }
+  }
+  return ce.True;
+}
+function generateTruthTable(expr, ce) {
+  const variables = extractVariables(expr);
+  if (variables.length > 10) {
+    return ce._fn("TruthTable", [expr]);
+  }
+  const rows = [];
+  const header = ce._fn("List", [
+    ...variables.map((v) => ce.string(v)),
+    ce.string("Result")
+  ]);
+  rows.push(header);
+  for (const assignment of generateAssignments(variables)) {
+    const result = evaluateWithAssignment(expr, assignment, ce);
+    const row = ce._fn("List", [
+      ...variables.map((v) => assignment[v] ? ce.True : ce.False),
+      result
+    ]);
+    rows.push(row);
+  }
+  return ce._fn("List", rows);
+}
+
 // src/compute-engine/library/logic.ts
 var LOGIC_LIBRARY = {
   True: {
@@ -32738,11 +33528,96 @@ var LOGIC_LIBRARY = {
     signature: "(boolean, boolean) -> boolean",
     evaluate: evaluateImplies
   },
-  Exists: { signature: "function", lazy: true },
-  NotExists: { signature: "function", lazy: true },
-  ExistsUnique: { signature: "function", lazy: true },
-  ForAll: { signature: "function", lazy: true },
-  NotForAll: { signature: "function", lazy: true },
+  Xor: {
+    description: "Exclusive or: true when an odd number of operands are true",
+    wikidata: "Q498186",
+    broadcastable: true,
+    associative: true,
+    commutative: true,
+    complexity: 10200,
+    signature: "(boolean+) -> boolean",
+    evaluate: evaluateXor
+  },
+  Nand: {
+    description: "Not-and: negation of conjunction",
+    wikidata: "Q189550",
+    broadcastable: true,
+    commutative: true,
+    complexity: 10200,
+    signature: "(boolean+) -> boolean",
+    evaluate: evaluateNand
+  },
+  Nor: {
+    description: "Not-or: negation of disjunction",
+    wikidata: "Q189561",
+    broadcastable: true,
+    commutative: true,
+    complexity: 10200,
+    signature: "(boolean+) -> boolean",
+    evaluate: evaluateNor
+  },
+  // Quantifiers return boolean values (they are propositions)
+  // They support evaluation over finite domains (e.g., ForAll with Element condition)
+  // The first argument can be:
+  // - a symbol (e.g., "x") for symbolic quantification
+  // - an Element expression (e.g., ["Element", "x", ["Set", 1, 2, 3]]) for finite domain evaluation
+  Exists: {
+    signature: "(value, boolean) -> boolean",
+    lazy: true,
+    scoped: true,
+    evaluate: evaluateExists
+  },
+  NotExists: {
+    signature: "(value, boolean) -> boolean",
+    lazy: true,
+    scoped: true,
+    evaluate: (args, options) => {
+      const result = evaluateExists(args, options);
+      if (result?.symbol === "True") return options.engine.False;
+      if (result?.symbol === "False") return options.engine.True;
+      return void 0;
+    }
+  },
+  ExistsUnique: {
+    signature: "(value, boolean) -> boolean",
+    lazy: true,
+    scoped: true,
+    evaluate: evaluateExistsUnique
+  },
+  ForAll: {
+    signature: "(value, boolean) -> boolean",
+    lazy: true,
+    scoped: true,
+    evaluate: evaluateForAll
+  },
+  NotForAll: {
+    signature: "(value, boolean) -> boolean",
+    lazy: true,
+    scoped: true,
+    evaluate: (args, options) => {
+      const result = evaluateForAll(args, options);
+      if (result?.symbol === "True") return options.engine.False;
+      if (result?.symbol === "False") return options.engine.True;
+      return void 0;
+    }
+  },
+  // Predicate application in First-Order Logic.
+  // ["Predicate", "P", "x"] represents the predicate P applied to x.
+  // This is semantically different from a function application: predicates
+  // return boolean values and are used in logical formulas.
+  // In LaTeX, P(x) inside a quantifier context parses to ["Predicate", "P", "x"].
+  Predicate: {
+    description: "Apply a predicate to arguments, returning a boolean",
+    signature: "(symbol, value+) -> boolean",
+    lazy: true,
+    // Predicates remain symbolic unless explicitly defined
+    evaluate: (args, { engine }) => {
+      if (args.length === 0) return void 0;
+      const pred = args[0];
+      if (!pred.symbol) return void 0;
+      return void 0;
+    }
+  },
   KroneckerDelta: {
     description: "Return 1 if the arguments are equal, 0 otherwise",
     signature: "(value+) -> integer",
@@ -32763,82 +33638,189 @@ var LOGIC_LIBRARY = {
     evaluate: (args, { engine: ce }) => args[0].symbol === "True" ? ce.One : ce.Zero
   }
 };
-function evaluateAnd(args, { engine: ce }) {
-  if (args.length === 0) return ce.True;
-  const ops = [];
-  for (const arg of args) {
-    if (arg.symbol === "False") return ce.False;
-    if (arg.symbol !== "True") {
-      let duplicate = false;
-      for (const x of ops) {
-        if (x.isSame(arg)) {
-          duplicate = true;
-        } else if (arg.operator === "Not" && arg.op1.isSame(x) || x.operator === "Not" && x.op1.isSame(arg)) {
-          return ce.False;
-        }
-      }
-      if (!duplicate) ops.push(arg);
-    }
-  }
-  if (ops.length === 0) return ce.True;
-  if (ops.length === 1) return ops[0];
-  return ce._fn("And", ops);
+function simplifyLogicFunction(x) {
+  const fn = {
+    And: evaluateAnd,
+    Or: evaluateOr,
+    Not: evaluateNot,
+    Equivalent: evaluateEquivalent,
+    Implies: evaluateImplies,
+    Xor: evaluateXor,
+    Nand: evaluateNand,
+    Nor: evaluateNor
+  }[x.operator];
+  if (!fn || !x.ops) return void 0;
+  const value = fn(x.ops, { engine: x.engine });
+  if (!value) return void 0;
+  return { value, because: "logic" };
 }
-function evaluateOr(args, { engine: ce }) {
-  if (args.length === 0) return ce.True;
-  const ops = [];
-  for (const arg of args) {
-    if (arg.symbol === "True") return ce.True;
-    if (arg.symbol !== "False") {
-      let duplicate = false;
-      for (const x of ops) {
-        if (x.isSame(arg)) {
-          duplicate = true;
-        } else if (arg.operator === "Not" && arg.op1.isSame(x) || x.operator === "Not" && x.op1.isSame(arg)) {
-          return ce.True;
-        }
+function evaluateForAll(args, { engine: ce }) {
+  if (args.length < 2) return void 0;
+  const condition = args[0];
+  const body = args[1];
+  const canonicalBody = body.canonical;
+  if (canonicalBody.symbol === "True") return ce.True;
+  if (canonicalBody.symbol === "False") return ce.False;
+  const variable = condition.symbol ?? condition.op1?.symbol;
+  if (variable && !bodyContainsVariable(canonicalBody, variable)) {
+    return canonicalBody.evaluate();
+  }
+  const domain = extractFiniteDomain(condition, ce);
+  if (domain) {
+    const nestedDomains = collectNestedDomains(body, ce);
+    if (nestedDomains.length > 0) {
+      return evaluateForAllCartesian(
+        [{ variable: domain.variable, values: domain.values }, ...nestedDomains],
+        getInnermostBody(body),
+        ce
+      );
+    }
+    for (const value of domain.values) {
+      const substituted = body.subs({ [domain.variable]: value }).canonical;
+      const result = substituted.evaluate();
+      if (result.symbol === "False") {
+        return ce.False;
+      }
+      if (result.symbol !== "True") {
+        return void 0;
       }
-      if (!duplicate) ops.push(arg);
     }
+    return ce.True;
   }
-  if (ops.length === 0) return ce.False;
-  if (ops.length === 1) return ops[0];
-  return ce._fn("Or", ops);
-}
-function evaluateNot(args, { engine: ce }) {
-  const op1 = args[0]?.symbol;
-  if (op1 === "True") return ce.False;
-  if (op1 === "False") return ce.True;
+  const bodyEval = canonicalBody.evaluate();
+  if (bodyEval.symbol === "True") return ce.True;
+  if (bodyEval.symbol === "False") return ce.False;
   return void 0;
 }
-function evaluateEquivalent(args, { engine: ce }) {
-  const lhs = args[0].symbol;
-  const rhs = args[1].symbol;
-  if (lhs === "True" && rhs === "True" || lhs === "False" && rhs === "False")
-    return ce.True;
-  if (lhs === "True" && rhs === "False" || lhs === "False" && rhs === "True")
+function evaluateExists(args, { engine: ce }) {
+  if (args.length < 2) return void 0;
+  const condition = args[0];
+  const body = args[1];
+  const canonicalBody = body.canonical;
+  if (canonicalBody.symbol === "True") return ce.True;
+  if (canonicalBody.symbol === "False") return ce.False;
+  const variable = condition.symbol ?? condition.op1?.symbol;
+  if (variable && !bodyContainsVariable(canonicalBody, variable)) {
+    return canonicalBody.evaluate();
+  }
+  const domain = extractFiniteDomain(condition, ce);
+  if (domain) {
+    const nestedDomains = collectNestedDomains(body, ce);
+    if (nestedDomains.length > 0) {
+      return evaluateExistsCartesian(
+        [{ variable: domain.variable, values: domain.values }, ...nestedDomains],
+        getInnermostBody(body),
+        ce
+      );
+    }
+    for (const value of domain.values) {
+      const substituted = body.subs({ [domain.variable]: value }).canonical;
+      const result = substituted.evaluate();
+      if (result.symbol === "True") {
+        return ce.True;
+      }
+    }
     return ce.False;
+  }
+  const bodyEval = canonicalBody.evaluate();
+  if (bodyEval.symbol === "True") return ce.True;
+  if (bodyEval.symbol === "False") return ce.False;
   return void 0;
 }
-function evaluateImplies(args, { engine: ce }) {
-  const lhs = args[0].symbol;
-  const rhs = args[1].symbol;
-  if (lhs === "True" && rhs === "True" || lhs === "False" && rhs === "False" || lhs === "False" && rhs === "True")
-    return ce.True;
-  if (lhs === "True" && rhs === "False") return ce.False;
+function evaluateExistsUnique(args, { engine: ce }) {
+  if (args.length < 2) return void 0;
+  const condition = args[0];
+  const body = args[1];
+  const domain = extractFiniteDomain(condition, ce);
+  if (domain) {
+    let count = 0;
+    for (const value of domain.values) {
+      const substituted = body.subs({ [domain.variable]: value }).canonical;
+      const result = substituted.evaluate();
+      if (result.symbol === "True") {
+        count++;
+        if (count > 1) return ce.False;
+      } else if (result.symbol !== "False") {
+        return void 0;
+      }
+    }
+    return count === 1 ? ce.True : ce.False;
+  }
   return void 0;
 }
-function simplifyLogicFunction(x) {
-  const value = {
-    And: evaluateAnd,
-    Or: evaluateOr,
-    Not: evaluateNot,
-    Equivalent: evaluateEquivalent,
-    Implies: evaluateImplies
-  }[x.operator]?.(x.engine, x.ops);
-  if (!value) return void 0;
-  return { value, because: "logic" };
-}
+var LOGIC_FUNCTION_LIBRARY = {
+  /**
+   * Convert a boolean expression to Conjunctive Normal Form (CNF).
+   * CNF is a conjunction (And) of disjunctions (Or) of literals.
+   * A literal is either a variable or its negation.
+   *
+   * Example: (A ∨ B) ∧ (¬A ∨ C)
+   */
+  ToCNF: {
+    signature: "(boolean) -> boolean",
+    evaluate: ([expr], { engine: ce }) => {
+      if (!expr) return void 0;
+      return toCNF(expr.evaluate(), ce);
+    }
+  },
+  /**
+   * Convert a boolean expression to Disjunctive Normal Form (DNF).
+   * DNF is a disjunction (Or) of conjunctions (And) of literals.
+   * A literal is either a variable or its negation.
+   *
+   * Example: (A ∧ B) ∨ (¬A ∧ C)
+   */
+  ToDNF: {
+    signature: "(boolean) -> boolean",
+    evaluate: ([expr], { engine: ce }) => {
+      if (!expr) return void 0;
+      return toDNF(expr.evaluate(), ce);
+    }
+  },
+  /**
+   * Check if a boolean expression is satisfiable.
+   * Returns True if there exists an assignment of truth values to variables
+   * that makes the expression true.
+   */
+  IsSatisfiable: {
+    signature: "(boolean) -> boolean",
+    evaluate: ([expr], { engine: ce }) => {
+      if (!expr) return void 0;
+      return isSatisfiable(expr, ce);
+    }
+  },
+  /**
+   * Check if a boolean expression is a tautology.
+   * Returns True if the expression is true for all possible assignments
+   * of truth values to variables.
+   */
+  IsTautology: {
+    signature: "(boolean) -> boolean",
+    evaluate: ([expr], { engine: ce }) => {
+      if (!expr) return void 0;
+      return isTautology(expr, ce);
+    }
+  },
+  /**
+   * Generate a truth table for a boolean expression.
+   * Returns a List of Lists, where each inner list contains the variable
+   * assignments followed by the result.
+   *
+   * Example: TruthTable(["And", "A", "B"]) returns:
+   * [["List", "A", "B", "Result"],
+   *  ["List", False, False, False],
+   *  ["List", False, True, False],
+   *  ["List", True, False, False],
+   *  ["List", True, True, True]]
+   */
+  TruthTable: {
+    signature: "(boolean) -> list",
+    evaluate: ([expr], { engine: ce }) => {
+      if (!expr) return void 0;
+      return generateTruthTable(expr, ce);
+    }
+  }
+};
 
 // src/compute-engine/library/number-theory.ts
 var NUMBER_THEORY_LIBRARY = [
@@ -35370,7 +36352,7 @@ var LIBRARIES = {
   "domains": [],
   // 'domains': getDomainsDictionary(),
   "linear-algebra": LINEAR_ALGEBRA_LIBRARY,
-  "logic": LOGIC_LIBRARY,
+  "logic": [LOGIC_LIBRARY, LOGIC_FUNCTION_LIBRARY],
   "number-theory": NUMBER_THEORY_LIBRARY,
   "numeric": [],
   // @todo   // 'numeric': [
@@ -35666,6 +36648,64 @@ function matchOnce(expr, pattern, substitution, options) {
     const ce = expr.engine;
     let result = null;
     const operator2 = pattern.operator;
+    if (operator2 === "Divide" && expr.numericValue !== null && !expr.denominator.is(1)) {
+      const divideExpr = ce.function(
+        "Divide",
+        [expr.numerator, expr.denominator],
+        { canonical: false, structural: true }
+      );
+      return matchArguments(divideExpr, pattern.ops, substitution, options);
+    }
+    if (operator2 === "Divide" && expr.operator === "Multiply") {
+      const ops = expr.ops;
+      for (let i = 0; i < ops.length; i++) {
+        const op = ops[i];
+        if (op.numericValue !== null && op.numerator.is(1) && !op.denominator.is(1)) {
+          const others = ops.filter((_, j) => j !== i);
+          const numerator = others.length === 1 ? others[0] : ce.function("Multiply", others, { canonical: false });
+          const divideExpr = ce.function(
+            "Divide",
+            [numerator, op.denominator],
+            { canonical: false, structural: true }
+          );
+          const result2 = matchArguments(
+            divideExpr,
+            pattern.ops,
+            substitution,
+            options
+          );
+          if (result2 !== null) return result2;
+        }
+      }
+    }
+    if (operator2 === "Power" && expr.operator === "Divide" && expr.op1.is(1)) {
+      const powerExpr = ce.function(
+        "Power",
+        [expr.op2, ce.number(-1)],
+        { canonical: false, structural: true }
+      );
+      const result2 = matchArguments(
+        powerExpr,
+        pattern.ops,
+        substitution,
+        options
+      );
+      if (result2 !== null) return result2;
+    }
+    if (operator2 === "Power" && expr.operator === "Root") {
+      const powerExpr = ce.function(
+        "Power",
+        [expr.op1, ce.box(["Divide", 1, expr.op2], { canonical: false })],
+        { canonical: false, structural: true }
+      );
+      const result2 = matchArguments(
+        powerExpr,
+        pattern.ops,
+        substitution,
+        options
+      );
+      if (result2 !== null) return result2;
+    }
     if (operator2.startsWith("_")) {
       result = captureWildcard(operator2, ce.box(expr.operator), substitution);
       if (result !== null)
@@ -38715,12 +39755,568 @@ var BoxedSymbol = class extends _BoxedExpression {
   }
 };
 
+// src/compute-engine/symbolic/simplify-sum.ts
+function simplifySum(x) {
+  if (x.operator !== "Sum") return void 0;
+  let body = x.op1;
+  const limits = x.op2;
+  if (!body || !limits || limits.operator !== "Limits") return void 0;
+  const index = limits.op1?.symbol;
+  const lower = limits.op2;
+  const upper = limits.op3;
+  if (!index || !lower || !upper) return void 0;
+  const ce = x.engine;
+  if (body.operator === "Sum" || body.operator === "Product") {
+    const simplifiedBody = body.simplify();
+    if (!simplifiedBody.isSame(body)) {
+      const newSum = ce.function("Sum", [simplifiedBody, limits]);
+      return { value: newSum, because: "simplified nested sum/product" };
+    }
+  }
+  if (lower.isNumberLiteral && upper.isNumberLiteral) {
+    const lowerVal = lower.numericValue;
+    const upperVal = upper.numericValue;
+    if (typeof lowerVal === "number" && typeof upperVal === "number" && Number.isInteger(lowerVal) && Number.isInteger(upperVal)) {
+      if (upperVal < lowerVal) {
+        return { value: ce.Zero, because: "empty sum" };
+      }
+      if (upperVal === lowerVal) {
+        return {
+          value: body.subs({ [index]: lower }).simplify(),
+          because: "single term sum"
+        };
+      }
+    }
+  }
+  const bodyUnknowns = new Set(body.unknowns);
+  if (!bodyUnknowns.has(index)) {
+    const count = upper.sub(lower).add(ce.One).simplify();
+    if (count.isNumberLiteral && count.numericValue !== null) {
+      const countVal = typeof count.numericValue === "number" ? count.numericValue : count.numericValue.re;
+      if (countVal <= 0) {
+        return { value: ce.Zero, because: "empty sum" };
+      }
+    }
+    return {
+      value: count.mul(body.simplify()),
+      because: "sum of constant"
+    };
+  }
+  if (body.symbol === index) {
+    const a = lower;
+    const b = upper;
+    const result = b.mul(b.add(ce.One)).sub(a.mul(a.sub(ce.One))).div(2);
+    return { value: result.simplify(), because: "triangular number" };
+  }
+  if (body.operator === "Power" && body.op1?.symbol === index && body.op2?.is(2) && lower.is(1)) {
+    const b = upper;
+    const result = b.mul(b.add(ce.One)).mul(b.mul(2).add(ce.One)).div(6);
+    return { value: result, because: "sum of squares" };
+  }
+  if (body.operator === "Power" && body.op1?.symbol === index && body.op2?.is(3) && lower.is(1)) {
+    const b = upper;
+    const triangular = b.mul(b.add(ce.One)).div(2);
+    return { value: triangular.pow(2), because: "sum of cubes" };
+  }
+  if (body.operator === "Power" && body.op1?.is(-1) && body.op2?.symbol === index && lower.is(0)) {
+    const b = upper;
+    const result = ce.One.add(ce.number(-1).pow(b)).div(2);
+    return { value: result, because: "alternating unit series" };
+  }
+  if (body.operator === "Multiply" && body.ops && lower.is(0)) {
+    let hasAlternating = false;
+    let hasIndex = false;
+    for (const op of body.ops) {
+      if (op.operator === "Power" && op.op1?.is(-1) && op.op2?.symbol === index) {
+        hasAlternating = true;
+      } else if (op.symbol === index) {
+        hasIndex = true;
+      }
+    }
+    if (hasAlternating && hasIndex && body.ops.length === 2) {
+      const b = upper;
+      const result = ce.function("Multiply", [
+        ce.function("Power", [ce.number(-1), b]),
+        ce.function("Floor", [
+          ce.function("Divide", [ce.function("Add", [b, ce.One]), ce.number(2)])
+        ])
+      ]);
+      return { value: result, because: "alternating linear series" };
+    }
+  }
+  if (body.operator === "Add" && body.ops) {
+    let constant = null;
+    let coefficient = null;
+    for (const term of body.ops) {
+      const termUnknowns = new Set(term.unknowns);
+      if (!termUnknowns.has(index)) {
+        constant = constant ? constant.add(term) : term;
+      } else if (term.symbol === index) {
+        coefficient = coefficient ? coefficient.add(ce.One) : ce.One;
+      } else if (term.operator === "Multiply" && term.ops?.some((op) => op.symbol === index)) {
+        const coef = term.ops.filter((op) => op.symbol !== index);
+        if (coef.length === term.ops.length - 1) {
+          const c = coef.length === 1 ? coef[0] : ce.function("Multiply", coef);
+          coefficient = coefficient ? coefficient.add(c) : c;
+        }
+      } else {
+        constant = null;
+        coefficient = null;
+        break;
+      }
+    }
+    if (constant !== null && coefficient !== null) {
+      const m = lower;
+      const b = upper;
+      if (lower.is(0)) {
+        const bPlus1 = ce.function("Add", [b, ce.One]);
+        const inner = ce.function("Add", [
+          constant,
+          ce.function("Divide", [
+            ce.function("Multiply", [coefficient, b]),
+            ce.number(2)
+          ])
+        ]);
+        const result = ce.function("Multiply", [bPlus1, inner]);
+        return { value: result, because: "arithmetic progression" };
+      } else {
+        const numTerms = ce.function("Add", [
+          ce.function("Subtract", [b, m]),
+          ce.One
+        ]);
+        const avgIndex = ce.function("Divide", [
+          ce.function("Add", [m, b]),
+          ce.number(2)
+        ]);
+        const avgValue = ce.function("Add", [
+          constant,
+          ce.function("Multiply", [coefficient, avgIndex])
+        ]);
+        const result = ce.function("Multiply", [numTerms, avgValue]);
+        return { value: result, because: "arithmetic progression" };
+      }
+    }
+  }
+  if (body.operator === "Power" && body.op2?.symbol === index && !new Set(body.op1?.unknowns ?? []).has(index)) {
+    const r = body.op1;
+    const b = upper;
+    if (lower.is(0)) {
+      const numerator = ce.One.sub(r.pow(b.add(ce.One)));
+      const denominator = ce.One.sub(r);
+      return { value: numerator.div(denominator), because: "geometric series" };
+    } else if (lower.is(1)) {
+      const numerator = r.sub(r.pow(b.add(ce.One)));
+      const denominator = ce.One.sub(r);
+      return { value: numerator.div(denominator), because: "geometric series" };
+    }
+  }
+  if (body.operator === "Binomial" && lower.is(0) && body.op2?.symbol === index) {
+    const n = body.op1;
+    if (n && upper.isSame(n)) {
+      const result = ce.function("Power", [ce.number(2), n]);
+      return { value: result, because: "sum of binomial coefficients" };
+    }
+  }
+  if (body.operator === "Multiply" && body.ops && lower.is(0)) {
+    let hasBinomial = false;
+    let hasAlternating = false;
+    let binomialN = null;
+    for (const op of body.ops) {
+      if (op.operator === "Binomial" && op.op2?.symbol === index) {
+        hasBinomial = true;
+        binomialN = op.op1 ?? null;
+      } else if (op.operator === "Power" && op.op1?.is(-1) && op.op2?.symbol === index) {
+        hasAlternating = true;
+      }
+    }
+    if (hasBinomial && hasAlternating && binomialN && upper.isSame(binomialN)) {
+      return { value: ce.Zero, because: "alternating binomial sum" };
+    }
+    let hasIndex = false;
+    binomialN = null;
+    hasBinomial = false;
+    for (const op of body.ops) {
+      if (op.symbol === index) {
+        hasIndex = true;
+      } else if (op.operator === "Binomial" && op.op2?.symbol === index) {
+        hasBinomial = true;
+        binomialN = op.op1 ?? null;
+      }
+    }
+    if (hasIndex && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 2) {
+      const n = binomialN;
+      const result = ce.function("Multiply", [
+        n,
+        ce.function("Power", [ce.number(2), n.sub(ce.One)])
+      ]);
+      return { value: result, because: "weighted binomial sum" };
+    }
+    let hasIndexSquared = false;
+    binomialN = null;
+    hasBinomial = false;
+    for (const op of body.ops) {
+      if (op.operator === "Power" && op.op1?.symbol === index && op.op2?.is(2)) {
+        hasIndexSquared = true;
+      } else if (op.operator === "Binomial" && op.op2?.symbol === index) {
+        hasBinomial = true;
+        binomialN = op.op1 ?? null;
+      }
+    }
+    if (hasIndexSquared && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 2) {
+      const n = binomialN;
+      const result = ce.function("Multiply", [
+        n,
+        n.add(ce.One),
+        ce.function("Power", [ce.number(2), n.sub(ce.number(2))])
+      ]);
+      return { value: result, because: "weighted squared binomial sum" };
+    }
+    let hasIndexCubed = false;
+    binomialN = null;
+    hasBinomial = false;
+    for (const op of body.ops) {
+      if (op.operator === "Power" && op.op1?.symbol === index && op.op2?.is(3)) {
+        hasIndexCubed = true;
+      } else if (op.operator === "Binomial" && op.op2?.symbol === index) {
+        hasBinomial = true;
+        binomialN = op.op1 ?? null;
+      }
+    }
+    if (hasIndexCubed && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 2) {
+      const n = binomialN;
+      const result = ce.function("Multiply", [
+        ce.function("Power", [n, ce.number(2)]),
+        n.add(ce.number(3)),
+        ce.function("Power", [ce.number(2), n.sub(ce.number(3))])
+      ]);
+      return { value: result, because: "weighted cubed binomial sum" };
+    }
+    let hasAltTerm = false;
+    let hasIndexTerm = false;
+    binomialN = null;
+    hasBinomial = false;
+    for (const op of body.ops) {
+      if (op.operator === "Power" && op.op1?.is(-1) && op.op2?.symbol === index) {
+        hasAltTerm = true;
+      } else if (op.symbol === index) {
+        hasIndexTerm = true;
+      } else if (op.operator === "Binomial" && op.op2?.symbol === index) {
+        hasBinomial = true;
+        binomialN = op.op1 ?? null;
+      }
+    }
+    if (hasAltTerm && hasIndexTerm && hasBinomial && binomialN && upper.isSame(binomialN) && body.ops.length === 3) {
+      return { value: ce.Zero, because: "alternating weighted binomial sum" };
+    }
+  }
+  if (body.operator === "Power" && body.op1?.operator === "Binomial" && body.op2?.is(2) && lower.is(0)) {
+    const binomial2 = body.op1;
+    const n = binomial2.op1;
+    const k = binomial2.op2;
+    if (n && k?.symbol === index && upper.isSame(n)) {
+      const result = ce.function("Binomial", [
+        ce.function("Multiply", [ce.number(2), n]),
+        n
+      ]);
+      return { value: result, because: "sum of binomial squares" };
+    }
+  }
+  if (body.operator === "Multiply" && body.ops?.length === 2 && lower.is(1)) {
+    const [op1, op2] = body.ops;
+    const isKTimesKPlus1 = op1.symbol === index && op2.operator === "Add" && op2.ops?.length === 2 && op2.ops.some((o) => o.symbol === index) && op2.ops.some((o) => o.is(1)) || op2.symbol === index && op1.operator === "Add" && op1.ops?.length === 2 && op1.ops.some((o) => o.symbol === index) && op1.ops.some((o) => o.is(1));
+    if (isKTimesKPlus1) {
+      const n = upper;
+      const result = ce.function("Divide", [
+        ce.function("Multiply", [
+          n,
+          ce.function("Add", [n, ce.One]),
+          ce.function("Add", [n, ce.number(2)])
+        ]),
+        ce.number(3)
+      ]);
+      return { value: result, because: "sum of k*(k+1)" };
+    }
+  }
+  if (body.operator === "Divide" && body.op1?.is(1) && body.op2?.operator === "Multiply") {
+    const denom = body.op2;
+    if (denom.ops?.length === 2) {
+      const [d1, d2] = denom.ops;
+      if (lower.is(1)) {
+        const isKTimesKPlus1 = d1.symbol === index && d2.operator === "Add" && d2.ops?.length === 2 && d2.ops.some((op) => op.symbol === index) && d2.ops.some((op) => op.is(1)) || d2.symbol === index && d1.operator === "Add" && d1.ops?.length === 2 && d1.ops.some((op) => op.symbol === index) && d1.ops.some((op) => op.is(1));
+        if (isKTimesKPlus1) {
+          const n = upper;
+          const result = n.div(n.add(ce.One));
+          return { value: result, because: "partial fractions (telescoping)" };
+        }
+      }
+      if (lower.is(2)) {
+        const isKTimesKMinus1 = d1.symbol === index && d2.operator === "Add" && d2.ops?.length === 2 && d2.ops.some((op) => op.symbol === index) && d2.ops.some((op) => op.is(-1)) || d2.symbol === index && d1.operator === "Add" && d1.ops?.length === 2 && d1.ops.some((op) => op.symbol === index) && d1.ops.some((op) => op.is(-1));
+        if (isKTimesKMinus1) {
+          const n = upper;
+          const result = n.sub(ce.One).div(n);
+          return { value: result, because: "partial fractions (telescoping k*(k-1))" };
+        }
+      }
+    }
+  }
+  if (body.operator === "Multiply" && body.ops) {
+    const constantFactors = [];
+    const indexFactors = [];
+    for (const factor2 of body.ops) {
+      const factorUnknowns = new Set(factor2.unknowns);
+      if (factorUnknowns.has(index)) {
+        indexFactors.push(factor2);
+      } else {
+        constantFactors.push(factor2);
+      }
+    }
+    if (constantFactors.length > 0 && indexFactors.length > 0) {
+      const constant = constantFactors.length === 1 ? constantFactors[0] : ce.function("Multiply", constantFactors);
+      const indexPart = indexFactors.length === 1 ? indexFactors[0] : ce.function("Multiply", indexFactors);
+      const newSum = ce.function("Sum", [indexPart, limits]);
+      return {
+        value: constant.mul(newSum),
+        because: "factor out constant from sum"
+      };
+    }
+  }
+  return void 0;
+}
+
+// src/compute-engine/symbolic/simplify-product.ts
+function simplifyProduct(x) {
+  if (x.operator !== "Product") return void 0;
+  let body = x.op1;
+  const limits = x.op2;
+  if (!body || !limits || limits.operator !== "Limits") return void 0;
+  const index = limits.op1?.symbol;
+  const lower = limits.op2;
+  const upper = limits.op3;
+  if (!index || !lower || !upper) return void 0;
+  const ce = x.engine;
+  if (body.operator === "Sum" || body.operator === "Product") {
+    const simplifiedBody = body.simplify();
+    if (!simplifiedBody.isSame(body)) {
+      const newProduct = ce.function("Product", [simplifiedBody, limits]);
+      return { value: newProduct, because: "simplified nested sum/product" };
+    }
+  }
+  if (lower.isNumberLiteral && upper.isNumberLiteral) {
+    const lowerVal = lower.numericValue;
+    const upperVal = upper.numericValue;
+    if (typeof lowerVal === "number" && typeof upperVal === "number" && Number.isInteger(lowerVal) && Number.isInteger(upperVal)) {
+      if (upperVal < lowerVal) {
+        return { value: ce.One, because: "empty product" };
+      }
+      if (upperVal === lowerVal) {
+        return {
+          value: body.subs({ [index]: lower }).simplify(),
+          because: "single term product"
+        };
+      }
+    }
+  }
+  const bodyUnknowns = new Set(body.unknowns);
+  if (!bodyUnknowns.has(index)) {
+    const count = upper.sub(lower).add(ce.One).simplify();
+    if (count.isNumberLiteral && count.numericValue !== null) {
+      const countVal = typeof count.numericValue === "number" ? count.numericValue : count.numericValue.re;
+      if (countVal <= 0) {
+        return { value: ce.One, because: "empty product" };
+      }
+    }
+    return {
+      value: body.simplify().pow(count),
+      because: "product of constant"
+    };
+  }
+  if (body.symbol === index && lower.is(1)) {
+    return {
+      value: ce.function("Factorial", [upper]),
+      because: "factorial"
+    };
+  }
+  if (body.operator === "Add" && body.ops?.length === 2 && lower.is(1)) {
+    const [op1, op2] = body.ops;
+    let indexTerm = null;
+    let constTerm = null;
+    if (op1.symbol === index && !new Set(op2.unknowns).has(index)) {
+      indexTerm = op1;
+      constTerm = op2;
+    } else if (op2.symbol === index && !new Set(op1.unknowns).has(index)) {
+      indexTerm = op2;
+      constTerm = op1;
+    }
+    if (indexTerm && constTerm) {
+      const b = upper;
+      const c = constTerm;
+      const result = ce.function("Divide", [
+        ce.function("Factorial", [ce.function("Add", [b, c])]),
+        ce.function("Factorial", [c])
+      ]);
+      return { value: result, because: "shifted factorial" };
+    }
+  }
+  if (body.operator === "Divide" && lower.is(1)) {
+    const num = body.op1;
+    const denom = body.op2;
+    if (denom?.symbol === index && num?.operator === "Add" && num.ops?.length === 2 && num.ops.some((o) => o.symbol === index) && num.ops.some((o) => o.is(1))) {
+      return { value: upper.add(ce.One), because: "telescoping product" };
+    }
+  }
+  if (body.operator === "Add" && body.ops?.length === 2 && lower.is(2)) {
+    let hasOne = false;
+    let hasNegInvSq = false;
+    for (const op of body.ops) {
+      if (op.is(1)) {
+        hasOne = true;
+      } else if (op.operator === "Negate" && op.op1?.operator === "Power" && op.op1.op1?.symbol === index && op.op1.op2?.is(-2)) {
+        hasNegInvSq = true;
+      } else if (op.operator === "Power" && op.op1?.symbol === index && op.op2?.is(-2)) {
+      } else if (op.operator === "Multiply" && op.ops?.some((o) => o.is(-1)) && op.ops?.some(
+        (o) => o.operator === "Power" && o.op1?.symbol === index && o.op2?.is(-2)
+      )) {
+        hasNegInvSq = true;
+      }
+    }
+    if (hasOne && hasNegInvSq) {
+      const n = upper;
+      const result = ce.function("Divide", [
+        ce.function("Add", [n, ce.One]),
+        ce.function("Multiply", [ce.number(2), n])
+      ]);
+      return { value: result, because: "Wallis-like product" };
+    }
+  }
+  if (body.operator === "Add" && body.ops?.length === 2 && lower.is(1)) {
+    const [op1, op2] = body.ops;
+    let hasLinearTerm = false;
+    let coefficient = 0;
+    let constantTerm = 0;
+    for (const op of body.ops) {
+      if (op.isNumberLiteral && typeof op.numericValue === "number") {
+        constantTerm = op.numericValue;
+      } else if (op.operator === "Multiply" && op.ops?.length === 2) {
+        const [a, b] = op.ops;
+        if (a.isNumberLiteral && typeof a.numericValue === "number" && b.symbol === index) {
+          coefficient = a.numericValue;
+          hasLinearTerm = true;
+        } else if (b.isNumberLiteral && typeof b.numericValue === "number" && a.symbol === index) {
+          coefficient = b.numericValue;
+          hasLinearTerm = true;
+        }
+      }
+    }
+    if (hasLinearTerm && coefficient === 2 && constantTerm === -1) {
+      const b = upper;
+      const result = ce.function("Factorial2", [
+        ce.function("Subtract", [
+          ce.function("Multiply", [ce.number(2), b]),
+          ce.One
+        ])
+      ]);
+      return { value: result, because: "odd double factorial" };
+    }
+  }
+  if (body.operator === "Multiply" && body.ops?.length === 2 && lower.is(1)) {
+    const [op1, op2] = body.ops;
+    if (op1.is(2) && op2.symbol === index || op2.is(2) && op1.symbol === index) {
+      const b = upper;
+      const result = ce.function("Multiply", [
+        ce.function("Power", [ce.number(2), b]),
+        ce.function("Factorial", [b])
+      ]);
+      return { value: result, because: "even double factorial" };
+    }
+  }
+  if (body.operator === "Add" && body.ops?.length === 2 && lower.is(0)) {
+    let base = null;
+    let hasIndex = false;
+    for (const op of body.ops) {
+      if (op.symbol === index) {
+        hasIndex = true;
+      } else if (!new Set(op.unknowns).has(index)) {
+        base = op;
+      }
+    }
+    if (hasIndex && base) {
+      const n = upper.add(ce.One).simplify();
+      const result = ce.function("Pochhammer", [base, n]);
+      return { value: result, because: "rising factorial (Pochhammer)" };
+    }
+  }
+  if (lower.is(0)) {
+    let base = null;
+    let hasNegIndex = false;
+    if (body.operator === "Subtract" && body.ops?.length === 2) {
+      const [op1, op2] = body.ops;
+      if (op2.symbol === index && !new Set(op1.unknowns).has(index)) {
+        base = op1;
+        hasNegIndex = true;
+      }
+    } else if (body.operator === "Add" && body.ops?.length === 2) {
+      for (const op of body.ops) {
+        if (op.operator === "Negate" && op.op1?.symbol === index) {
+          hasNegIndex = true;
+        } else if (!new Set(op.unknowns).has(index)) {
+          base = op;
+        }
+      }
+    }
+    if (hasNegIndex && base) {
+      const n = upper.add(ce.One).simplify();
+      const result = ce.function("Divide", [
+        ce.function("Factorial", [base]),
+        ce.function("Factorial", [base.sub(n)])
+      ]);
+      return { value: result, because: "falling factorial" };
+    }
+  }
+  if (body.operator === "Multiply" && body.ops) {
+    const constantFactors = [];
+    const indexFactors = [];
+    for (const factor2 of body.ops) {
+      const factorUnknowns = new Set(factor2.unknowns);
+      if (factorUnknowns.has(index)) {
+        indexFactors.push(factor2);
+      } else {
+        constantFactors.push(factor2);
+      }
+    }
+    if (constantFactors.length > 0 && indexFactors.length > 0) {
+      const constant = constantFactors.length === 1 ? constantFactors[0] : ce.function("Multiply", constantFactors);
+      const indexPart = indexFactors.length === 1 ? indexFactors[0] : ce.function("Multiply", indexFactors);
+      const count = upper.sub(lower).add(ce.One).simplify();
+      const newProduct = ce.function("Product", [indexPart, limits]);
+      return {
+        value: constant.pow(count).mul(newProduct),
+        because: "factor out constant from product"
+      };
+    }
+  }
+  return void 0;
+}
+
 // src/compute-engine/symbolic/simplify-rules.ts
 var SIMPLIFY_RULES = [
   // The Golden Ratio, a constant that can be simplified
   "\\varphi -> \\frac{1+\\sqrt{5}}{2}",
   simplifyRelationalOperator,
   simplifySystemOfEquations,
+  //
+  // Cancel common polynomial factors in Divide expressions
+  // e.g., (x² - 1)/(x - 1) → x + 1
+  // Must run before expand to preserve polynomial structure
+  //
+  (x) => {
+    if (x.operator !== "Divide") return void 0;
+    const unknowns = x.unknowns;
+    if (unknowns.length !== 1) return void 0;
+    const variable = unknowns[0];
+    const result = cancelCommonFactors(x, variable);
+    if (result.isSame(x)) return void 0;
+    return { value: result, because: "cancel common polynomial factors" };
+  },
   // Try to expand the expression:
   // x*(y+z) -> x*y + x*z
   // { replace: (x) => expand(x) ?? undefined, id: 'expand' },
@@ -38810,7 +40406,8 @@ var SIMPLIFY_RULES = [
     const ce = x.engine;
     if (s === void 0) return void 0;
     if (s === "positive") return { value: ce.One, because: "sign positive" };
-    if (s === "negative") return { value: ce.One, because: "sign negative" };
+    if (s === "negative")
+      return { value: ce.NegativeOne, because: "sign negative" };
     if (s === "zero") return { value: ce.Zero, because: "sign zero" };
     if (s === "unsigned") return { value: ce.NaN, because: "sign unsinged" };
     return void 0;
@@ -38893,14 +40490,10 @@ var SIMPLIFY_RULES = [
       because: "congruent"
     };
   },
-  //
-  // Product, Sum
-  //
-  (x) => {
-    if (x.operator === "Max") {
-    }
-    return void 0;
-  },
+  // Sum simplification (extracted to simplify-sum.ts)
+  simplifySum,
+  // Product simplification (extracted to simplify-product.ts)
+  simplifyProduct,
   //
   // Constructible values of trig functions
   //
@@ -41126,7 +42719,8 @@ var ComputeEngine = class _ComputeEngine {
         return BoxedType.unknown;
       },
       parseUnexpectedToken: (_lhs, _parser) => null,
-      preserveLatex: false
+      preserveLatex: false,
+      quantifierScope: "tight"
     };
     const result = parse2(
       asLatexString(latex) ?? latex,
@@ -41279,10 +42873,10 @@ function defToString(name, def, v) {
 }
 
 // src/compute-engine.ts
-var version = "0.31.0";
+var version = "0.32.1";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.31.0"
+  version: "0.32.1"
 };
 export {
   BoxedType,