fix: update inline snapshots in arithmetic, calculus, derivatives, and logic tests for accuracy

- Corrected inline snapshots for sum evaluations in arithmetic tests.
- Adjusted inline snapshots for indefinite integration in calculus tests.
- Fixed derivative results for hyperbolic functions and other expressions in derivatives tests.
- Simplified quantifier evaluations in logic tests by removing unnecessary array structures.
- Enhanced inline snapshots for LaTeX syntax tests, ensuring clarity in expected outputs.
- Updated polynomial division regression tests to reflect accurate simplifications.

Author: arnog

src/compute-engine/boxed-expression/ascii-math.ts

@@ -201,6 +201,7 @@ const FUNCTIONS: Record<
   string | ((expr: BoxedExpression, serialize: AsciiMathSerializer) => string)
 > = {
   Abs: (expr: BoxedExpression, serialize) => `|${serialize(expr.op1)}|`,
+  Norm: (expr: BoxedExpression, serialize) => `||${serialize(expr.op1)}||`,
 
   // Trigonometric functions
   Sin: 'sin',

src/compute-engine/boxed-expression/box.ts

@@ -532,13 +532,15 @@ function makeCanonicalFunction(
     result = new BoxedFunction(
       ce,
       name,
-      validateArguments(
-        ce,
-        xs,
-        opDef.signature.type,
-        opDef.lazy,
-        opDef.broadcastable
-      ) ?? xs,
+      opDef.inferredSignature
+        ? xs
+        : validateArguments(
+            ce,
+            xs,
+            opDef.signature.type,
+            opDef.lazy,
+            opDef.broadcastable
+          ) ?? xs,
       { metadata, canonical: true, scope }
     );
     return result;
@@ -583,13 +585,18 @@ function makeCanonicalFunction(
     opDef.associative ? name : undefined
   );
 
-  const adjustedArgs = validateArguments(
-    ce,
-    args,
-    opDef.signature.type,
-    opDef.lazy,
-    opDef.broadcastable
-  );
+  // Skip validation for function literals with inferred signatures.
+  // These will be validated during evaluation by the lambda function,
+  // which handles currying and partial application.
+  const adjustedArgs = opDef.inferredSignature
+    ? null
+    : validateArguments(
+        ce,
+        args,
+        opDef.signature.type,
+        opDef.lazy,
+        opDef.broadcastable
+      );
 
   // If we have some adjusted arguments, the arguments did not
   // match the parameters of the signature. We're done.

src/compute-engine/boxed-expression/boxed-function.ts

@@ -174,13 +174,19 @@ export class BoxedFunction extends _BoxedExpression {
         this.engine._typeResolver
       );
     } else if (isSignatureType(def.signature.type)) {
+      // Preserve the argument information when updating the result type
+      const oldSig = def.signature.type;
       def.signature = new BoxedType(
         {
           kind: 'signature',
+          args: oldSig.args,
+          optArgs: oldSig.optArgs,
+          variadicArg: oldSig.variadicArg,
+          variadicMin: oldSig.variadicMin,
           result:
             inferenceMode === 'narrow'
-              ? narrow(def.signature.type.result, t)
-              : widen(def.signature.type.result, t),
+              ? narrow(oldSig.result, t)
+              : widen(oldSig.result, t),
         },
         this.engine._typeResolver
       );

src/compute-engine/boxed-expression/boxed-operator-definition.ts

@@ -320,6 +320,20 @@ export class _BoxedOperatorDefinition implements BoxedOperatorDefinition {
       if (!boxedFn.isValid)
         throw Error(`Invalid function ${boxedFn.toString()}`);
 
+      // If no explicit signature was provided and the evaluate handler is a
+      // Function expression, infer the signature from the function parameters
+      // and body type.
+      if (this.inferredSignature && boxedFn.operator === 'Function') {
+        const body = boxedFn.ops![0];
+        const params = boxedFn.ops!.slice(1);
+        const bodyType = body.type.toString();
+        const paramTypes = params.map(() => 'unknown').join(', ');
+        this.signature = new BoxedType(
+          `(${paramTypes}) -> ${bodyType}`,
+          this.engine._typeResolver
+        );
+      }
+
       const fn = applicable(boxedFn);
       evaluate = (xs) => fn(xs);
       Object.defineProperty(evaluate, 'toString', {

src/compute-engine/boxed-expression/simplify.ts

@@ -13,6 +13,59 @@ type InternalSimplifyOptions = SimplifyOptions & {
   useVariations: boolean;
 };
 
+const BASIC_ARITHMETIC = [
+  'Add',
+  'Subtract',
+  'Multiply',
+  'Divide',
+  'Negate',
+  'Power',
+  'Rational',
+];
+
+// Trig functions with constructible special values
+const CONSTRUCTIBLE_TRIG = ['Sin', 'Cos', 'Tan', 'Csc', 'Sec', 'Cot'];
+
+/**
+ * Check if an expression contains a constructible trig function somewhere
+ * in its subexpressions. Used to determine if we need to recursively
+ * simplify an operand to get constructible value simplification.
+ */
+function containsConstructibleTrig(expr: BoxedExpression): boolean {
+  if (CONSTRUCTIBLE_TRIG.includes(expr.operator)) return true;
+  if (!expr.ops) return false;
+  return expr.ops.some((op) => containsConstructibleTrig(op));
+}
+
+/**
+ * Recursively evaluate purely numeric subexpressions without full simplification.
+ * This handles cases like Power(x, Add(1,2)) where Add(1,2) should become 3.
+ * Unlike full simplification, this won't expand polynomial factors.
+ */
+function evaluateNumericSubexpressions(expr: BoxedExpression): BoxedExpression {
+  // Number literals are already simplified
+  if (expr.isNumberLiteral) return expr;
+
+  // No ops means symbol or other atomic - return as is
+  if (!expr.ops) return expr;
+
+  // If purely numeric (no unknowns), evaluate the whole expression
+  if (expr.unknowns.length === 0 && BASIC_ARITHMETIC.includes(expr.operator)) {
+    const evaluated = expr.evaluate();
+    if (evaluated.isNumberLiteral) return evaluated;
+  }
+
+  // Otherwise, recursively process operands
+  const newOps = expr.ops.map((op) => evaluateNumericSubexpressions(op));
+
+  // Check if anything changed
+  const changed = newOps.some((op, i) => op !== expr.ops![i]);
+  if (!changed) return expr;
+
+  // Reconstruct with _fn to avoid re-canonicalization
+  return expr.engine._fn(expr.operator, newOps);
+}
+
 export function simplify(
   expr: BoxedExpression,
   options?: Partial<InternalSimplifyOptions>,
@@ -120,33 +173,75 @@ function simplifyOperands(
 
   const def = expr.operatorDefinition;
 
-  // For scoped functions (Sum, Product), use holdMap but simplify non-body operands
+  // For scoped functions (Sum, Product, D), use holdMap but simplify non-body operands
   if (def?.scoped === true) {
     const simplifiedOps = expr.ops.map((x, i) => {
       // Don't simplify the body (first operand) to allow pattern-matching rules to work
       if (i === 0) return x;
       // Simplify other operands (like Limits)
       return simplify(x, options).at(-1)!.value;
     });
-    return expr.engine.function(expr.operator, simplifiedOps);
+    // Use _fn() to bypass canonicalization - operands are already canonical.
+    // This avoids triggering handlers like D's canonicalFunctionLiteralArguments
+    // which would add extra Function wrappers.
+    return expr.engine._fn(expr.operator, simplifiedOps);
   }
 
-  // For lazy but non-scoped functions (Multiply, Add), we need a balanced approach:
-  // - Respect holdMap for evaluation semantics
-  // - But also simplify Sum/Product operands that result from other simplification rules
+  // For non-scoped functions, we need to balance simplification with holdMap semantics
 
   // First get the operands through holdMap
   const ops = holdMap(expr, (x) => x);
 
-  // Then simplify any Sum/Product operands specifically
+  // For lazy functions (Multiply, Add), only simplify Sum/Product operands
+  // and expressions containing constructible trig functions
+  // to avoid interfering with their special handling in simplify-rules
+  if (def?.lazy) {
+    const simplifiedOps = ops.map((x) => {
+      if (
+        x.operator === 'Sum' ||
+        x.operator === 'Product' ||
+        containsConstructibleTrig(x)
+      ) {
+        return simplify(x, options).at(-1)!.value;
+      }
+      return x;
+    });
+    return expr.engine.function(expr.operator, simplifiedOps);
+  }
+
+  // For non-lazy, non-scoped functions (e.g., Factorial2, Sqrt, Degrees),
+  // recursively simplify operands. This ensures expressions like Factorial2(-1 + 2*3)
+  // become Factorial2(5) and Degrees(tan(90-0.000001)) becomes Degrees(tan(89.999999)).
+  //
+  // EXCEPTION: For Divide expressions, only evaluate purely numeric subexpressions
+  // but don't do full recursive simplification. This preserves factored polynomial
+  // structure for the cancelCommonFactors rule.
+  // e.g., (x-1)(x+2)/((x-1)(x+3)) should cancel to (x+2)/(x+3), not expand first.
+  // But x^(1+2)/(1+2) should still simplify to x^3/3.
+  if (expr.operator === 'Divide') {
+    const simplifiedOps = ops.map((x) => evaluateNumericSubexpressions(x));
+    const changed = simplifiedOps.some((op, i) => op !== ops[i]);
+    if (!changed) return expr;
+    return expr.engine._fn(expr.operator, simplifiedOps);
+  }
+
   const simplifiedOps = ops.map((x) => {
-    if (x.operator === 'Sum' || x.operator === 'Product') {
+    // For purely numeric basic arithmetic expressions, evaluate directly
+    // to get simpler results like √(1+2) → √3
+    if (!x.isNumberLiteral && x.ops && x.unknowns.length === 0) {
+      if (BASIC_ARITHMETIC.includes(x.operator)) {
+        const evaluated = x.evaluate();
+        if (evaluated.isNumberLiteral) return evaluated;
+      }
+    }
+    // For other expressions with ops (like Tan, Sqrt, etc.), recursively simplify
+    if (x.ops) {
       return simplify(x, options).at(-1)!.value;
     }
     return x;
   });
-
-  return expr.engine.function(expr.operator, simplifiedOps);
+  // Use _fn() since operands are already canonical (simplified above)
+  return expr.engine._fn(expr.operator, simplifiedOps);
 }
 
 function simplifyExpression(

src/compute-engine/index.ts

@@ -2077,6 +2077,8 @@ function assignValueAsValue(
   if (typeof value === 'number' || typeof value === 'bigint')
     return ce.number(value);
   const expr = ce.box(value);
+  // Explicit function expressions should always be treated as operator definitions
+  if (expr.operator === 'Function') return undefined;
   if (expr.unknowns.some((s) => s.startsWith('_'))) {
     // If the expression has wildcards, it should be treated as a function
     // E.g. ["Add", "_", 1] or ["Add", "_x", 1]
@@ -2099,7 +2101,10 @@ function assignValueAsOperatorDef(
   const body = canonicalFunctionLiteral(ce.box(value));
   if (body === undefined) return undefined;
 
-  return { evaluate: body, signature: 'function' };
+  // Don't set an explicit signature - let it be inferred from the body.
+  // This ensures inferredSignature = true, which allows the return type
+  // to be properly narrowed during type checking (e.g., in Add operands).
+  return { evaluate: body };
 }
 
 function defToString(

src/compute-engine/library/logic-utils.ts

@@ -6,13 +6,63 @@ import { asSmallInteger } from '../boxed-expression/numerics';
  * Extracted from logic.ts for better code organization.
  */
 
+/**
+ * Check if an And expression is a contradiction (contains A and Not(A)).
+ * Non-recursive to avoid infinite loops.
+ */
+function isContradiction(
+  args: ReadonlyArray<BoxedExpression>
+): boolean {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    for (let j = i + 1; j < args.length; j++) {
+      const other = args[j];
+      if (
+        (arg.operator === 'Not' && arg.op1.isSame(other)) ||
+        (other.operator === 'Not' && other.op1.isSame(arg))
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if an Or expression is a tautology (contains A and Not(A)).
+ * Non-recursive to avoid infinite loops.
+ */
+function isTautologyCheck(
+  args: ReadonlyArray<BoxedExpression>
+): boolean {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    for (let j = i + 1; j < args.length; j++) {
+      const other = args[j];
+      if (
+        (arg.operator === 'Not' && arg.op1.isSame(other)) ||
+        (other.operator === 'Not' && other.op1.isSame(arg))
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 export function evaluateAnd(
   args: ReadonlyArray<BoxedExpression>,
   { engine: ce }: { engine: ComputeEngine }
 ): BoxedExpression | undefined {
   if (args.length === 0) return ce.True;
   const ops: BoxedExpression[] = [];
-  for (const arg of args) {
+  for (let arg of args) {
+    // Check if an Or operand is a tautology (contains A and Not(A))
+    // For example: Or(A, Not(A)) -> True, and And(..., True, ...) simplifies
+    if (arg.operator === 'Or' && isTautologyCheck(arg.ops!)) {
+      arg = ce.True;
+    }
+
     // ['And', ... , 'False', ...] -> 'False'
     if (arg.symbol === 'False') return ce.False;
     if (arg.symbol !== 'True') {
@@ -46,7 +96,13 @@ export function evaluateOr(
 ): BoxedExpression | undefined {
   if (args.length === 0) return ce.True;
   const ops: BoxedExpression[] = [];
-  for (const arg of args) {
+  for (let arg of args) {
+    // Check if an And operand is a contradiction (contains A and Not(A))
+    // For example: And(A, Not(A)) -> False, and Or(..., False, ...) is removed
+    if (arg.operator === 'And' && isContradiction(arg.ops!)) {
+      arg = ce.False;
+    }
+
     // ['Or', ... , 'True', ...] -> 'True'
     if (arg.symbol === 'True') return ce.True;
     if (arg.symbol !== 'False') {

src/compute-engine/library/sets.ts

@@ -483,10 +483,10 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     complexity: 11200,
     // EL-3: Extended signature to support optional condition for filtered iteration
     // The condition is used by Sum/Product to filter values when iterating
-    signature: '(value, collection, any?) -> boolean',
+    signature: '(value, collection, boolean?) -> boolean',
     description:
       'Test whether a value is an element of a collection. ' +
-      'Optional third argument is a condition for filtered iteration in Sum/Product.',
+      'Optional third argument is a boolean expression (condition) for filtered iteration in Sum/Product.',
     evaluate: ([value, collection, _condition], { engine: ce }) => {
       // Note: condition is only used during Sum/Product iteration,
       // not for standalone Element evaluation