@cortex-js/compute-engine 0.26.0 → 0.26.3

package/README.md

@@ -9,7 +9,7 @@
 notation interchange format based on JSON.
 
 The Cortex Compute Engine can parse LaTeX to MathJSON, serialize MathJSON to
-LaTeX, format, simplify and evaluate MathJSON expressions.
+LaTeX or MathASCII, format, simplify and evaluate MathJSON expressions.
 
 Reference documentation and guides at
 [cortexjs.io/compute-engine](https://cortexjs.io/compute-engine/).
@@ -23,20 +23,19 @@ $ npm install --save @cortex-js/compute-engine
 ```
 
 ```js
-import { parse, evaluate } from "@cortex-js/compute-engine";
+import { ComputeEngine } from "@cortex-js/compute-engine";
 
-const expr = parse("2^{11}-1 \\in \\P");
+const ce = new ComputeEngine();
 
-console.log(expr);
-// ➔ ["Element", ["Subtract", ["Power", 2, 11] , 1], "PrimeNumber"]
-
-console.log(evaluate(expr));
-// ➔ "False"
+ce.parse("2^{11}-1 \\in \\Z").evaluate().print()
+// ➔ "True"
 ```
 
-## More
+## FAQ
+
+**Q** How do I build the project?
 
-- [Build](BUILD.md) instructions
+[Build](BUILD.md) instructions
 
 ## Related Projects
 

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.26.0 */
+/** Compute Engine 0.26.3 */
 
 // src/compute-engine/boxed-expression/public.ts
 function isRuleStep(x) {
@@ -4022,6 +4022,7 @@ Invalid type
 function parseType(s) {
   if (s === void 0) return void 0;
   if (isValidType(s)) return s;
+  if (typeof s !== "string") return void 0;
   if (PRIMITIVE_TYPES.includes(s)) return s;
   const parser = new TypeParser(s);
   return parser.parse();
@@ -4597,6 +4598,7 @@ var ARROW_PRECEDENCE = 270;
 var ADDITION_PRECEDENCE = 275;
 var MULTIPLICATION_PRECEDENCE = 390;
 var DIVISION_PRECEDENCE = 600;
+var EXPONENTIATION_PRECEDENCE = 700;
 var POSTFIX_PRECEDENCE = 810;
 function isExpressionEntry(entry) {
   return !("kind" in entry) || entry.kind === "expression";
@@ -6458,20 +6460,20 @@ function isSymbolDefinition(def) {
   if (def === void 0 || def === null || typeof def !== "object")
     return false;
   if (isBoxedExpression(def)) return false;
-  if ("type" in def || "value" in def || "constant" in def) {
-    if (typeof def.type === "function") {
+  if ("value" in def || "constant" in def || "inferred" in def) {
+    if ("type" in def && typeof def.type === "function") {
       throw new Error(
-        "The type field of a symbol definition should be a type string"
+        "The `type` field of a symbol definition should be of type `string`"
       );
     }
     if ("signature" in def) {
       throw new Error(
-        "Symbol definition cannot have a signature field. Use a type field instead."
+        "Symbol definition cannot have a `signature` field. Use a `type` field instead."
       );
     }
     if ("sgn" in def) {
       throw new Error(
-        "Symbol definition cannot have a sgn field. Use a flags field instead."
+        "Symbol definition cannot have a `sgn` field. Use a `flags.sgn` field instead."
       );
     }
     return true;
@@ -6485,22 +6487,23 @@ function isFunctionDefinition(def) {
   if ("signature" in def || "complexity" in def) {
     if ("constant" in def) {
       throw new Error(
-        "Function definition cannot have a constant field and symbol definition cannot have a signature field."
+        "Function definition cannot have a `constant` field and symbol definition cannot have a `signature` field."
       );
     }
-    if ("type" in def && typeof def.type !== "function") {
-      throw new Error(
-        "The type field of a function definition should be a function"
-      );
-    }
-    if ("sgn" in def && typeof def.sgn !== "function") {
-      throw new Error(
-        "The sgn field of a function definition should be a function"
-      );
-    }
-    return true;
   }
-  return false;
+  if (!("evaluate" in def) && !("signature" in def) && !("sgn" in def) && !("complexity" in def) && !("canonical" in def))
+    return false;
+  if ("type" in def && typeof def.type !== "function") {
+    throw new Error(
+      "The `type` field of a function definition should be a function"
+    );
+  }
+  if ("sgn" in def && typeof def.sgn !== "function") {
+    throw new Error(
+      "The `sgn` field of a function definition should be a function"
+    );
+  }
+  return true;
 }
 function semiCanonical(ce, xs) {
   if (!xs.every((x) => isBoxedExpression(x))) return xs.map((x) => ce.box(x));
@@ -7502,7 +7505,9 @@ function fromDigits(s, baseInput) {
   }
   return [value, ""];
 }
-function numberToString(num) {
+function numberToString(num, fractionalDigits) {
+  if (typeof fractionalDigits === "number" && typeof num === "number")
+    return num.toFixed(fractionalDigits);
   const numStr = num.toString();
   if (typeof num === "number" && Number.isInteger(num) && numStr.includes("e")) {
     const fixedStr = BigInt(num).toString();
@@ -7534,11 +7539,13 @@ function bigintValue(expr) {
   if (s === "-infinity") return null;
   return bigint(s);
 }
-function numberToExpression(num) {
+function numberToExpression(num, fractionalDigits) {
   if (typeof num === "number") {
     if (isNaN(num)) return "NaN";
     if (!Number.isFinite(num))
       return num < 0 ? "NegativeInfinity" : "PositiveInfinity";
+    if (typeof fractionalDigits === "number")
+      return { num: num.toFixed(fractionalDigits) };
     return num;
   }
   if (num >= Number.MIN_SAFE_INTEGER && num <= Number.MAX_SAFE_INTEGER)
@@ -7672,7 +7679,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     return result.mul(this.bignum(this.radical).sqrt());
   }
   get numerator() {
-    if (this.rational[1] === 1) return this;
+    if (this.rational[1] == 1) return this;
     return this.clone({
       rational: isMachineRational(this.rational) ? [this.rational[0], 1] : [this.rational[0], BigInt(1)],
       radical: this.radical
@@ -7714,10 +7721,10 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
     return Number.isNaN(this.rational[0]);
   }
   get isPositiveInfinity() {
-    return this.rational[0] === Infinity;
+    return this.rational[0] == Infinity;
   }
   get isNegativeInfinity() {
-    return this.rational[0] === -Infinity;
+    return this.rational[0] == -Infinity;
   }
   get isComplexInfinity() {
     return false;
@@ -7859,7 +7866,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
         exponent = { re: exponent.re, im: exponent.im };
       } else {
         if (exponent instanceof _ExactNumericValue) {
-          if (exponent.radical === 1 && exponent.rational[0] === 1)
+          if (exponent.radical === 1 && exponent.rational[0] == 1)
             return this.root(exponent.rational[0]);
         }
         exponent = exponent.re;
@@ -7941,7 +7948,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
       return this.factory({ im: Math.pow(-this.re, 1 / exponent) });
     if (this.radical > SMALL_INTEGER || this.rational[0] > SMALL_INTEGER || this.rational[0] < -SMALL_INTEGER || this.rational[1] > SMALL_INTEGER)
       return this.factory(this.bignumRe).root(exponent);
-    if (this.rational[1] === 1) {
+    if (this.rational[1] == 1) {
       const root2 = Math.pow(this.rational[0], 1 / exponent);
       if (Number.isInteger(root2)) return this.clone(root2);
     }
@@ -8007,7 +8014,7 @@ var ExactNumericValue = class _ExactNumericValue extends NumericValue {
   }
   eq(other) {
     if (typeof other === "number")
-      return this.radical === 1 && isInteger(this.rational) && this.rational[0] === other;
+      return this.radical === 1 && isInteger(this.rational) && this.rational[0] == other;
     if (other instanceof _ExactNumericValue) {
       return this.radical === other.radical && this.rational[0] == other.rational[0] && this.rational[1] == other.rational[1];
     }
@@ -8171,7 +8178,7 @@ function asSmallInteger(expr) {
 // src/compute-engine/boxed-expression/polynomials.ts
 function totalDegree(expr) {
   if (expr.symbol && !expr.isConstant) return 1;
-  if (expr.operator === "Power" && expr.op2.numericValue !== null) {
+  if (expr.operator === "Power" && expr.op2.isNumberLiteral) {
     if (totalDegree(expr.op1) === 0) return 0;
     const deg = asSmallInteger(expr.op2);
     if (deg !== null && deg > 0) return deg;
@@ -8196,7 +8203,7 @@ function totalDegree(expr) {
 }
 function maxDegree(expr) {
   if (expr.symbol && !expr.isConstant) return 1;
-  if (expr.operator === "Power" && expr.op2.numericValue !== null) {
+  if (expr.operator === "Power" && expr.op2.isNumberLiteral) {
     if (maxDegree(expr.op1) === 0) return 0;
     const deg = asSmallInteger(expr.op2);
     if (deg !== null && deg > 0) return deg;
@@ -9505,6 +9512,16 @@ function expandAll(expr) {
 }
 
 // src/compute-engine/boxed-expression/negate.ts
+function canonicalNegate(expr) {
+  let sign2 = -1;
+  while (expr.operator === "Negate") {
+    expr = expr.op1;
+    sign2 = -sign2;
+  }
+  if (sign2 === 1) return expr;
+  if (expr.isNumberLiteral) return expr.neg();
+  return expr.engine._fn("Negate", [expr]);
+}
 function negate(expr) {
   let sign2 = -1;
   while (expr.operator === "Negate") {
@@ -9517,9 +9534,7 @@ function negate(expr) {
   if (expr.operator === "Subtract") return expr.op2.sub(expr.op1);
   if (expr.operator === "Add") return add3(...expr.ops.map((x) => negate(x)));
   if (expr.operator === "Multiply") return negateProduct(ce, expr.ops);
-  if (expr.operator === "Divide") {
-    return negate(expr.op1).div(expr.op2);
-  }
+  if (expr.operator === "Divide") return negate(expr.op1).div(expr.op2);
   return ce._fn("Negate", [expr]);
 }
 function negateProduct(ce, args) {
@@ -9581,7 +9596,10 @@ function canonicalMultiply(ce, ops) {
       if (next.operator === "Sqrt" && next.op1.isNumberLiteral && isSubtype(next.op1.type, "finite_integer")) {
         let radical = next.op1.numericValue;
         if (typeof radical !== "number") radical = radical.re;
-        if (radical >= SMALL_INTEGER) continue;
+        if (radical >= SMALL_INTEGER) {
+          ys.push(x);
+          continue;
+        }
         if (isSubtype(x.type, "finite_rational")) {
           const rational = x.numericValue;
           const [num, den] = typeof rational === "number" ? [rational, 1] : [rational.numerator.re, rational.denominator.re];
@@ -9674,6 +9692,7 @@ function mulN(...xs) {
 function canonicalDivide(op1, op2) {
   const ce = op1.engine;
   if (!op1.isValid || !op2.isValid) return ce._fn("Divide", [op1, op2]);
+  if (op1.isNaN || op2.isNaN) return ce.NaN;
   if (op2.is(0)) return op1.is(0) ? ce.NaN : ce.ComplexInfinity;
   if (op1.is(0)) return ce.Zero;
   if (op2.is(0) === false) {
@@ -9873,9 +9892,11 @@ var Product = class _Product {
           return;
         }
         if (term.isInfinity) {
-          this.coefficient = this.engine._numericValue(
-            term.isNegative ? -Infinity : Infinity
-          );
+          if (isOne(exp2)) {
+            this.coefficient = this.engine._numericValue(
+              term.isNegative ? -Infinity : Infinity
+            );
+          } else this.terms.push({ term, exponent: exp2 });
           return;
         }
         if (isOne(exp2)) {
@@ -10030,8 +10051,15 @@ var Product = class _Product {
     const ce = this.engine;
     const coef = this.coefficient;
     if (coef.isZero) return [ce.Zero, ce.One];
-    if (coef.isPositiveInfinity || coef.isNegativeInfinity)
+    if (coef.isPositiveInfinity || coef.isNegativeInfinity) {
+      if (this.terms.length === 0) {
+        return [
+          coef.isPositiveInfinity ? ce.PositiveInfinity : ce.NegativeInfinity,
+          ce.One
+        ];
+      }
       return [ce.NaN, ce.NaN];
+    }
     const isNegativeOne2 = coef.isNegativeOne;
     if (isNegativeOne2) this.coefficient = ce._numericValue(1);
     const xs = this.groupedByDegrees({ mode: "rational" });
@@ -10598,13 +10626,23 @@ function evalTrig(name, op) {
         (x) => x.sinh(),
         (x) => x.sinh()
       );
-    case "Tan":
-      return applyAngle(
+    case "Tan": {
+      const result = applyAngle(
         op,
-        Math.tan,
-        (x) => x.toSignificantDigits(ce.precision + 4).tan().toSignificantDigits(ce.precision),
+        (x) => {
+          const y = Math.tan(x);
+          if (y > 1e6 || y < -1e6) return ce.ComplexInfinity;
+          return y;
+        },
+        (x) => {
+          const y = x.tan();
+          if (y.greaterThan(1e6) || y.lessThan(-1e6)) return ce.ComplexInfinity;
+          return y;
+        },
         (x) => x.tan()
       );
+      return result;
+    }
     case "Tanh":
       return applyAngle(
         op,
@@ -10838,9 +10876,11 @@ function canonicalRoot(a, b) {
   if (exp2 === 1) return a;
   if (exp2 === 2) {
     if (a.isNumberLiteral && isSubtype(a.type, "rational")) {
-      const v = a.sqrt();
-      if (typeof v.numericValue === "number") return v;
-      if (v.numericValue.isExact) return v;
+      if (a.re < SMALL_INTEGER) {
+        const v = a.sqrt();
+        if (typeof v.numericValue === "number") return v;
+        if (v.numericValue.isExact) return v;
+      }
     }
     return ce._fn("Sqrt", [a]);
   }
@@ -11608,10 +11648,9 @@ function makeLambda(expr) {
     ce.resetContext();
     let i = 0;
     for (const param of params) ce.assign(param, args[i++]);
-    const result = fn.N() ?? fn.evaluate();
+    const result = fn.evaluate();
     ce.swapScope(context);
-    if (!result.isValid) return void 0;
-    return result;
+    return result.isValid ? result : void 0;
   };
 }
 function apply3(fn, args) {
@@ -13041,7 +13080,7 @@ var ARITHMETIC_LIBRARY = [
       sgn: ([x]) => x.isNonNegative ? "positive" : x.isNegative || x.isReal === false ? "unsigned" : void 0,
       canonical: (args, { engine }) => {
         const x = args[0];
-        if (x.numericValue !== null && x.isNegative)
+        if (x.isNumberLiteral && x.isNegative)
           return engine._fn("Factorial", [x.neg()]).neg();
         return engine._fn("Factorial", [x]);
       },
@@ -13408,7 +13447,7 @@ var ARITHMETIC_LIBRARY = [
         const [base, exp2] = args;
         return canonicalRoot(base, exp2);
       },
-      evaluate: ([x, n], { numericApproximation }) => x.root(n)
+      evaluate: ([x, n], { numericApproximation }) => root(x, n, { numericApproximation })
     },
     Round: {
       complexity: 1250,
@@ -18124,6 +18163,9 @@ function serializeRepeatingDecimals(s, options) {
   fractionalPart += lastDigit;
   while (fractionalPart.endsWith("0"))
     fractionalPart = fractionalPart.slice(0, -1);
+  if (typeof options.fractionalDigits === "number") {
+    fractionalPart = fractionalPart.slice(0, options.fractionalDigits);
+  }
   if (exponent)
     return `${wholepart}.${fractionalPart}${exponent.toLowerCase()}`;
   return `${wholepart}.${fractionalPart}`;
@@ -18278,7 +18320,7 @@ function serializeJsonNumber(ce, value, options, metadata) {
         metadata.latex = metadata.latex ?? ce.box({ num: value.toString() }).latex;
       if (metadata.latex !== void 0)
         return { num: value.toString(), latex: metadata.latex };
-      return shorthandAllowed ? numberToExpression(value) : { num: numberToString(value) };
+      return shorthandAllowed ? numberToExpression(value, options.fractionalDigits) : { num: numberToString(value, options.fractionalDigits) };
     }
   }
   let result;
@@ -18440,6 +18482,8 @@ var _BoxedExpression = class {
       }
       if (options.fractionalDigits === "auto")
         defaultOptions.fractionalDigits = -this.engine.precision;
+      if (typeof options.fractionalDigits === "number")
+        defaultOptions.fractionalDigits = options.fractionalDigits;
     }
     const opts = {
       ...defaultOptions,
@@ -18496,6 +18540,7 @@ var _BoxedExpression = class {
     };
     if (options?.fractionalDigits === "auto")
       effectiveOptions.fractionalDigits = -this.engine.precision;
+    else effectiveOptions.fractionalDigits = options?.fractionalDigits ?? "max";
     if (typeof effectiveOptions.fractionalDigits === "number" && effectiveOptions.fractionalDigits > this.engine.precision)
       effectiveOptions.fractionalDigits = this.engine.precision;
     effectiveOptions = {
@@ -18624,7 +18669,7 @@ var _BoxedExpression = class {
     return null;
   }
   get isNumberLiteral() {
-    return this.numericValue !== null;
+    return false;
   }
   get isFunctionExpression() {
     return false;
@@ -18797,6 +18842,9 @@ var _BoxedExpression = class {
   simplify(_options) {
     return this;
   }
+  expand() {
+    return expand2(this) ?? this;
+  }
   evaluate(_options) {
     return this.simplify();
   }
@@ -21293,7 +21341,7 @@ function invisibleOperatorForm(expr) {
   return expr.engine._fn(expr.operator, expr.ops.map(invisibleOperatorForm));
 }
 function numberForm(expr) {
-  if (expr.numericValue !== null) return expr.canonical;
+  if (expr.isNumberLiteral) return expr.canonical;
   if (expr.ops) return expr.engine._fn(expr.operator, expr.ops.map(numberForm));
   return expr;
 }
@@ -21424,10 +21472,10 @@ function boxFunction(ce, name, ops, options) {
       if (typeof op1 === "number") return ce.number(-op1, options);
       if (op1 instanceof Decimal) return ce.number(op1.neg(), options);
       const boxedop1 = ce.box(op1, options);
-      ops = [boxedop1];
       const num = boxedop1.numericValue;
       if (num !== null)
         return ce.number(typeof num === "number" ? -num : num.neg(), options);
+      ops = [boxedop1];
     }
   }
   if (options.canonical === true)
@@ -21576,7 +21624,7 @@ function makeNumericFunction(ce, name, semiOps, metadata) {
   } else return null;
   if (!ops.every((x) => x.isValid)) return ce._fn(name, ops, metadata);
   if (name === "Add") return canonicalAdd(ce, ops);
-  if (name === "Negate") return ops[0].neg();
+  if (name === "Negate") return canonicalNegate(ops[0]);
   if (name === "Multiply") return canonicalMultiply(ce, ops);
   if (name === "Divide") {
     if (ops.length === 2)
@@ -21719,8 +21767,15 @@ var DERIVATIVES_TABLE = {
   Log: ["Power", ["Multiply", "_", ["Ln", "10"]], -1],
   Sqrt: ["Multiply", ["Power", "_", ["Negate", "Half"]], "Half"],
   Abs: [
-    "Piecewise",
-    ["Tuple", ["Multiply", "_", ["Power", "_", -1]], ["Greater", "_", 0]]
+    "Which",
+    ["Equal", "_", 0],
+    NaN,
+    ["Less", "_", 0],
+    -1,
+    ["Greater", "_", 0],
+    1,
+    "True",
+    ["D", ["Abs", "_"], "_"]
   ],
   // https://proofwiki.org/wiki/Derivative_of_Error_Function
   Erf: [
@@ -21794,7 +21849,7 @@ function derivative(fn, order2) {
 function differentiate(expr, v) {
   const ce = expr.engine;
   if (expr.string) return void 0;
-  if (expr.numericValue !== null) return expr.engine.Zero;
+  if (expr.isNumberLiteral) return expr.engine.Zero;
   if (expr.symbol === v) return expr.engine.One;
   if (expr.symbol) return expr.engine.Zero;
   if (!expr.operator) return void 0;
@@ -23404,8 +23459,10 @@ var LOGIC_LIBRARY = {
     evaluate: evaluateImplies
   },
   Exists: { signature: "function", hold: true },
+  NotExists: { signature: "function", hold: true },
   ExistsUnique: { signature: "function", hold: true },
   ForAll: { signature: "function", hold: true },
+  NotForAll: { signature: "function", hold: true },
   KroneckerDelta: {
     description: "Return 1 if the arguments are equal, 0 otherwise",
     signature: "(value, ...value) -> integer",
@@ -24575,9 +24632,9 @@ var TRIGONOMETRY_LIBRARY = [
         }
         return ce.number(fArg).div(180).mul(ce.Pi);
       },
-      evaluate: (ops, { engine: ce }) => {
-        if (ce.angularUnit === "deg") return ops[0];
-        return ops[0].mul(ce.Pi.div(180)).evaluate();
+      evaluate: (ops, options) => {
+        if (options.engine.angularUnit === "deg") return ops[0];
+        return ops[0].mul(options.engine.Pi.div(180)).evaluate(options);
       }
     },
     // Hypot: sqrt(x*x + y*y)
@@ -25265,6 +25322,9 @@ var BoxedNumber = class extends _BoxedExpression {
   get numericValue() {
     return this._value;
   }
+  get isNumberLiteral() {
+    return true;
+  }
   get re() {
     if (typeof this._value === "number") return this._value;
     return this._value.re;
@@ -25388,7 +25448,7 @@ var BoxedNumber = class extends _BoxedExpression {
     if (typeof this._value === "number") {
       if (this._value === 0 || this._value === 1) return this;
       if (this._value === -1) return this.engine.I;
-      if (this._value > 0 && Number.isInteger(this._value))
+      if (this._value > 0 && Number.isInteger(this._value) && this._value < SMALL_INTEGER)
         return this.engine.number(
           this.engine._numericValue({ radical: this._value })
         );
@@ -25644,12 +25704,10 @@ function canonicalNumberString(ce, s) {
   }
   const n = bigint(s);
   if (n !== null) {
-    if (n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER)
-      return Number(n);
+    if (n >= -SMALL_INTEGER && n <= SMALL_INTEGER) return Number(n);
     return ce._numericValue(n);
   }
-  const b = ce.bignum(s);
-  return isInMachineRange(b) ? b.toNumber() : ce._numericValue(b);
+  return ce._numericValue(ce.bignum(s));
 }
 
 // src/compute-engine/boxed-expression/boxed-symbol.ts
@@ -27008,14 +27066,12 @@ var DEFINITIONS_ARITHMETIC = [
     name: "Negate",
     latexTrigger: ["-"],
     kind: "prefix",
-    precedence: ADDITION_PRECEDENCE + 2,
+    precedence: EXPONENTIATION_PRECEDENCE + 1,
     parse: (parser, terminator) => {
       parser.skipSpace();
-      if (/\d/.test(parser.peek)) return null;
-      if (parser.parseNumber() !== null) return null;
       const rhs = parser.parseExpression({
         ...terminator,
-        minPrec: ADDITION_PRECEDENCE + 3
+        minPrec: EXPONENTIATION_PRECEDENCE + 3
       });
       if (rhs === null) return null;
       return ["Negate", rhs];
@@ -27106,7 +27162,7 @@ var DEFINITIONS_ARITHMETIC = [
     latexTrigger: ["^"],
     kind: "infix",
     serialize: serializePower
-    // Parsing is done as a special case in `parseExpression`
+    // Parsing is done as a special case in `parseSupsub`
   },
   {
     latexTrigger: "\\prod",
@@ -27830,6 +27886,24 @@ var DEFINITIONS_LOGIC = [
     serialize: "\\exists!",
     parse: parseQuantifier("ExistsUnique")
   },
+  {
+    name: "NotForAll",
+    kind: "prefix",
+    latexTrigger: ["\\lnot", "\\forall"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE
+    serialize: "\\lnot\\forall",
+    parse: parseQuantifier("NotForAll")
+  },
+  {
+    name: "NotExists",
+    kind: "prefix",
+    latexTrigger: ["\\lnot", "\\exists"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE,
+    serialize: "\\lnot\\exists",
+    parse: parseQuantifier("NotExists")
+  },
   {
     name: "KroneckerDelta",
     kind: "prefix",
@@ -27897,14 +27971,11 @@ function parseQuantifier(kind) {
     if (id) {
       parser.skipSpace();
       if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-        const body = parser.parseExpression(terminator);
-        return [kind, id, missingIfEmpty(body)];
-      }
-      if (parser.match("(")) {
-        const body = parser.parseExpression(terminator);
-        if (!parser.match(")")) return null;
-        return [kind, id, missingIfEmpty(body)];
+        const body2 = parser.parseExpression(terminator);
+        return [kind, id, missingIfEmpty(body2)];
       }
+      const body = parser.parseEnclosure();
+      if (body) return [kind, id, missingIfEmpty(body)];
     }
     parser.index = index;
     const condition = parser.parseExpression(terminator);
@@ -32923,7 +32994,7 @@ var ComputeEngine = class _ComputeEngine {
     }
     if ("radical" in value || "rational" in value) {
       if (value.radical !== void 0 && (!Number.isInteger(value.radical) || value.radical >= SMALL_INTEGER)) {
-        return makeNumericValue(value);
+        throw Error("Unexpected value for radical part:" + value.radical);
       }
       if (value.rational) {
         if (isMachineRational(value.rational)) {
@@ -33220,11 +33291,19 @@ Invalid definition for ${id}`, err.message].join("\n|   ") + "\n"
     {
       const type2 = parseType(def);
       if (!isValidType(type2)) {
+        if (typeof def === "object" && "N" in def) {
+          throw Error(
+            [
+              `Invalid argument for "${id}"`,
+              "Use `evaluate` handler instead of `N`"
+            ].join("\n|   ")
+          );
+        }
         throw Error(
           [
             `Invalid argument for "${id}"`,
             def.toString(),
-            `Use a type, a FunctionDefinition or a SymbolDefinition`
+            `Use a type, a \`FunctionDefinition\` or a \`SymbolDefinition\``
           ].join("\n|   ")
         );
       }
@@ -34315,10 +34394,10 @@ function mark(line, mark2) {
 }
 
 // src/compute-engine.ts
-var version = "0.26.0";
+var version = "0.26.3";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.26.0"
+  version: "0.26.3"
 };
 export {
   ComputeEngine,