@cortex-js/compute-engine 0.31.0 → 0.32.1

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.31.0 */
+/** Compute Engine 0.32.1 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -7869,7 +7869,11 @@ var ComputeEngine = (() => {
           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(
@@ -7883,13 +7887,20 @@ var ComputeEngine = (() => {
         }
       }
     }
+    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
@@ -8170,8 +8181,9 @@ var ComputeEngine = (() => {
     },
     {
       name: "GCD",
-      latexTrigger: ["\\gcd"]
+      latexTrigger: ["\\gcd"],
       // command from amsmath package
+      kind: "function"
     },
     {
       symbolTrigger: "gcd",
@@ -8229,9 +8241,14 @@ var ComputeEngine = (() => {
     },
     {
       name: "LCM",
-      symbolTrigger: "lcm",
+      latexTrigger: ["\\lcm"],
       kind: "function"
     },
+    {
+      symbolTrigger: "lcm",
+      kind: "function",
+      parse: "LCM"
+    },
     {
       symbolTrigger: "LCM",
       kind: "function",
@@ -8505,7 +8522,11 @@ var ComputeEngine = (() => {
     {
       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"],
@@ -10615,40 +10636,43 @@ var ComputeEngine = (() => {
       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
     {
@@ -10667,7 +10691,7 @@ var ComputeEngine = (() => {
       name: "Nand",
       kind: "infix",
       latexTrigger: ["\\barwedge"],
-      precedence: 315
+      precedence: 232
       // serialize: '\\mid',
     },
     {
@@ -10675,7 +10699,7 @@ var ComputeEngine = (() => {
       kind: "infix",
       latexTrigger: ["\u22BD"],
       // bar vee
-      precedence: 315
+      precedence: 232
       // serialize: '\\downarrow',
     },
     // Functions
@@ -10771,7 +10795,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\forall"],
       precedence: 200,
       // Has to be lower than COMPARISON_PRECEDENCE
-      serialize: "\\forall",
+      serialize: serializeQuantifier("\\forall"),
       parse: parseQuantifier("ForAll")
     },
     {
@@ -10780,7 +10804,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\exists"],
       precedence: 200,
       // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: "\\exists",
+      serialize: serializeQuantifier("\\exists"),
       parse: parseQuantifier("Exists")
     },
     {
@@ -10789,7 +10813,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\exists", "!"],
       precedence: 200,
       // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: "\\exists!",
+      serialize: serializeQuantifier("\\exists!"),
       parse: parseQuantifier("ExistsUnique")
     },
     {
@@ -10798,7 +10822,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\lnot", "\\forall"],
       precedence: 200,
       // Has to be lower than COMPARISON_PRECEDENCE
-      serialize: "\\lnot\\forall",
+      serialize: serializeQuantifier("\\lnot\\forall"),
       parse: parseQuantifier("NotForAll")
     },
     {
@@ -10807,7 +10831,7 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\lnot", "\\exists"],
       precedence: 200,
       // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: "\\lnot\\exists",
+      serialize: serializeQuantifier("\\lnot\\exists"),
       parse: parseQuantifier("NotExists")
     },
     {
@@ -10868,19 +10892,53 @@ var ComputeEngine = (() => {
         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;
@@ -10888,11 +10946,16 @@ var ComputeEngine = (() => {
       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)];
       }
@@ -11381,7 +11444,7 @@ var ComputeEngine = (() => {
         "\\ch": "Cosh",
         // Non-standard
         "\\cos": "Cos",
-        "\\cosh": "Csch",
+        "\\cosh": "Cosh",
         "\\cosec": "Csc",
         // Non-standard
         "\\cot": "Cot",
@@ -13293,8 +13356,41 @@ var ComputeEngine = (() => {
     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 = "";
@@ -13394,6 +13490,18 @@ var ComputeEngine = (() => {
         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;
     }
@@ -14279,9 +14387,10 @@ var ComputeEngine = (() => {
         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();
@@ -14291,6 +14400,18 @@ var ComputeEngine = (() => {
             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;
@@ -14339,12 +14460,16 @@ var ComputeEngine = (() => {
           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 {
@@ -14354,6 +14479,10 @@ var ComputeEngine = (() => {
       } 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) {
@@ -14742,9 +14871,24 @@ var ComputeEngine = (() => {
     }
     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
@@ -18627,7 +18771,10 @@ var ComputeEngine = (() => {
     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;
@@ -21666,8 +21813,6 @@ var ComputeEngine = (() => {
       }
       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;
@@ -22546,10 +22691,6 @@ var ComputeEngine = (() => {
       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) {
@@ -23056,7 +23197,8 @@ var ComputeEngine = (() => {
     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
@@ -23277,11 +23419,11 @@ var ComputeEngine = (() => {
       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) {
@@ -25397,7 +25539,7 @@ ${lines.join("\n")}`;
         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";
@@ -26439,38 +26581,29 @@ ${lines.join("\n")}`;
         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: {
@@ -26482,36 +26615,31 @@ ${lines.join("\n")}`;
         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;
+        }
       }
     }
   ];
@@ -26701,17 +26829,12 @@ ${lines.join("\n")}`;
     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",
@@ -26720,51 +26843,36 @@ ${lines.join("\n")}`;
     ],
     // 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;
@@ -26817,6 +26925,15 @@ ${lines.join("\n")}`;
       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);
@@ -26853,7 +26970,7 @@ ${lines.join("\n")}`;
       );
     }
     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;
@@ -27434,6 +27551,14 @@ ${e.message}`);
       // 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"],
@@ -27569,27 +27694,140 @@ ${e.message}`);
       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();
@@ -28451,40 +28689,46 @@ ${e.message}`);
       ],
       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]
             ]
           ]
         ],
@@ -28492,23 +28736,24 @@ ${e.message}`);
       ],
       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]
             ]
           ]
         ],
@@ -29322,6 +29567,8 @@ ${e.message}`);
           }
           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();
         }
@@ -29448,7 +29695,7 @@ ${e.message}`);
         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
       }
     },
@@ -30961,12 +31208,22 @@ ${e.message}`);
           }
           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: {
@@ -32696,6 +32953,539 @@ ${e.message}`);
     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: {
@@ -32766,11 +33556,96 @@ ${e.message}`);
       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",
@@ -32791,82 +33666,189 @@ ${e.message}`);
       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 = [
@@ -35398,7 +36380,7 @@ ${e.message}`);
     "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': [
@@ -35694,6 +36676,64 @@ Error in definition of "${name}"`,
       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)
@@ -38743,12 +39783,568 @@ Error in definition of "${name}"`,
     }
   };
 
+  // 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' },
@@ -38838,7 +40434,8 @@ Error in definition of "${name}"`,
       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;
@@ -38921,14 +40518,10 @@ Error in definition of "${name}"`,
         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
     //
@@ -41154,7 +42747,8 @@ Error in definition of "${name}"`,
           return BoxedType.unknown;
         },
         parseUnexpectedToken: (_lhs, _parser) => null,
-        preserveLatex: false
+        preserveLatex: false,
+        quantifierScope: "tight"
       };
       const result = parse2(
         asLatexString(latex) ?? latex,
@@ -41307,10 +42901,10 @@ Error in definition of "${name}"`,
   }
 
   // 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"
   };
   return __toCommonJS(compute_engine_exports);
 })();