feat: enhance handling of non-enumerable domains to remain symbolic in evaluations

Author: arnog

CHANGELOG.md

@@ -91,6 +91,14 @@
     - `["Interval", ["Open", 0], 5]` → iterates 1, 2, 3, 4, 5 (excludes 0)
     - `["Interval", 1, ["Open", 6]]` → iterates 1, 2, 3, 4, 5 (excludes 6)
 
+  - **Non-enumerable domains stay symbolic**: When the domain cannot be enumerated
+    (unknown symbol, infinite set, or symbolic bounds), the expression now stays
+    symbolic instead of returning NaN:
+    - `\sum_{n \in S} n` with unknown `S` → stays as `["Sum", "n", ["Element", "n", "S"]]`
+    - `\sum_{n \in \N} n` with infinite set → stays symbolic
+    - `\sum_{n \in [1,a]} n` with symbolic bound → stays symbolic
+    - Previously these would all return `NaN` with no explanation
+
 - **Linear Algebra Enhancements**: Improved tensor and matrix operations with
   better scalar handling, new functionality, and clearer error messages:
 
@@ -117,6 +125,14 @@
     - `ZeroMatrix(m, n?)`: Creates an m×n matrix of zeros (square if n omitted)
     - `OnesMatrix(m, n?)`: Creates an m×n matrix of ones (square if n omitted)
 
+  - **Matrix and Vector Norms**: Added `Norm` function for computing various
+    norms:
+    - **Vector norms**: L1 (sum of absolute values), L2 (Euclidean, default),
+      L-infinity (max absolute value), and general Lp norms
+    - **Matrix norms**: Frobenius (default, sqrt of sum of squared elements),
+      L1 (max column sum), L-infinity (max row sum)
+    - Scalar norms return the absolute value
+
   - **Diagonal function**: Now fully implemented with bidirectional behavior:
     - Vector → Matrix: Creates a diagonal matrix from a vector
       (`Diagonal([1,2,3])` → 3×3 diagonal matrix)

src/compute-engine/library/arithmetic.ts

@@ -50,7 +50,7 @@ import {
   mulN,
   canonicalDivide,
 } from '../boxed-expression/arithmetic-mul-div';
-import { canonicalBigop, reduceBigOp } from './utils';
+import { canonicalBigop, reduceBigOp, NON_ENUMERABLE_DOMAIN } from './utils';
 import {
   canonicalPower,
   canonicalRoot,
@@ -1516,31 +1516,41 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
         canonicalBigop('Product', body, bounds, scope),
 
       evaluate: (ops, options) => {
+        const ce = options.engine;
         const result = run(
           reduceBigOp(
             ops[0],
             ops.slice(1),
             (acc: BoxedExpression, x) => acc.mul(x.evaluate(options)),
-            options.engine.One
+            ce.One
           ),
-          options.engine._timeRemaining
+          ce._timeRemaining
         );
+        // If domain is non-enumerable, keep expression unevaluated (symbolic)
+        if (result === NON_ENUMERABLE_DOMAIN) {
+          return undefined; // Return undefined to keep expression symbolic
+        }
         // Evaluate the accumulated result to combine numeric factors
-        return result?.evaluate() ?? options.engine.NaN;
+        return result?.evaluate() ?? ce.NaN;
       },
 
       evaluateAsync: async (ops, options) => {
+        const ce = options.engine;
         const result = await runAsync(
           reduceBigOp(
             ops[0],
             ops.slice(1),
             (acc: BoxedExpression, x) => acc.mul(x.evaluate(options)),
-            options.engine.One
+            ce.One
           ),
-          options.engine._timeRemaining,
+          ce._timeRemaining,
           options.signal
         );
-        return result?.evaluate() ?? options.engine.NaN;
+        // If domain is non-enumerable, keep expression unevaluated (symbolic)
+        if (result === NON_ENUMERABLE_DOMAIN) {
+          return undefined; // Return undefined to keep expression symbolic
+        }
+        return result?.evaluate() ?? ce.NaN;
       },
     },
 
@@ -1567,6 +1577,10 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           ),
           engine._timeRemaining
         );
+        // If domain is non-enumerable, keep expression unevaluated (symbolic)
+        if (result === NON_ENUMERABLE_DOMAIN) {
+          return undefined; // Return undefined to keep expression symbolic
+        }
         // Evaluate the accumulated result to combine numeric terms
         // e.g., 3x + 1 + 2 + 3 → 3x + 6
         return result?.evaluate() ?? engine.NaN;
@@ -1583,6 +1597,10 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           engine._timeRemaining,
           signal
         );
+        // If domain is non-enumerable, keep expression unevaluated (symbolic)
+        if (result === NON_ENUMERABLE_DOMAIN) {
+          return undefined; // Return undefined to keep expression symbolic
+        }
         return result?.evaluate() ?? engine.NaN;
       },
     },

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

@@ -11,26 +11,43 @@ import {
  * Extracted from logic.ts for better code organization.
  */
 
+/**
+ * Result of extracting a finite domain from an Element expression.
+ * - `status: 'success'` - Domain was successfully extracted
+ * - `status: 'non-enumerable'` - Domain exists but cannot be enumerated (e.g., infinite set, unknown symbol)
+ * - `status: 'error'` - Invalid Element expression (missing variable, malformed domain)
+ */
+export type ExtractDomainResult =
+  | { status: 'success'; variable: string; values: BoxedExpression[] }
+  | { status: 'non-enumerable'; variable: string; domain: BoxedExpression; reason: string }
+  | { status: 'error'; reason: string };
+
 /**
  * Extract the finite domain from a quantifier's condition.
  * Supports:
  * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
  * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
  * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
- * Returns null if the domain is not finite or not recognized.
+ * Returns detailed result indicating success, non-enumerable domain, or error.
  */
-export function extractFiniteDomain(
+export function extractFiniteDomainWithReason(
   condition: BoxedExpression,
   ce: ComputeEngine
-): { variable: string; values: BoxedExpression[] } | null {
+): ExtractDomainResult {
   // Check for ["Element", var, set] pattern
-  if (condition.operator !== 'Element') return null;
+  if (condition.operator !== 'Element') {
+    return { status: 'error', reason: 'expected-element-expression' };
+  }
 
   const variable = condition.op1?.symbol;
-  if (!variable) return null;
+  if (!variable) {
+    return { status: 'error', reason: 'expected-index-variable' };
+  }
 
   const domain = condition.op2;
-  if (!domain) return null;
+  if (!domain) {
+    return { status: 'error', reason: 'expected-domain' };
+  }
 
   // Handle explicit sets: ["Set", 1, 2, 3]
   if (domain.operator === 'Set' || domain.operator === 'List') {
@@ -49,13 +66,19 @@ export function extractFiniteDomain(
             for (let i = start; i <= end; i++) {
               rangeValues.push(ce.number(i));
             }
-            return { variable, values: rangeValues };
+            return { status: 'success', variable, values: rangeValues };
+          }
+          if (count > 1000) {
+            return { status: 'non-enumerable', variable, domain, reason: 'domain-too-large' };
           }
         }
       }
-      return { variable, values: [...values] };
+      return { status: 'success', variable, values: [...values] };
     }
-    return null;
+    if (values && values.length > 1000) {
+      return { status: 'non-enumerable', variable, domain, reason: 'domain-too-large' };
+    }
+    return { status: 'error', reason: 'empty-domain' };
   }
 
   // Handle Range: ["Range", start, end] or ["Range", start, end, step]
@@ -75,10 +98,14 @@ export function extractFiniteDomain(
         for (let i = start; step > 0 ? i <= end : i >= end; i += step) {
           values.push(ce.number(i));
         }
-        return { variable, values };
+        return { status: 'success', variable, values };
+      }
+      if (count > 1000) {
+        return { status: 'non-enumerable', variable, domain, reason: 'domain-too-large' };
       }
     }
-    return null;
+    // Range with non-integer or symbolic bounds
+    return { status: 'non-enumerable', variable, domain, reason: 'non-integer-bounds' };
   }
 
   // Handle finite integer Interval: ["Interval", start, end]
@@ -120,12 +147,52 @@ export function extractFiniteDomain(
         for (let i = start; i <= end; i++) {
           values.push(ce.number(i));
         }
-        return { variable, values };
+        return { status: 'success', variable, values };
       }
+      if (count > 1000) {
+        return { status: 'non-enumerable', variable, domain, reason: 'domain-too-large' };
+      }
+    }
+    // Interval with non-integer or symbolic bounds
+    return { status: 'non-enumerable', variable, domain, reason: 'non-integer-bounds' };
+  }
+
+  // Check for known infinite sets (e.g., NonNegativeIntegers, Integers, Reals, etc.)
+  if (domain.symbol) {
+    const knownInfiniteSets = [
+      'Integers', 'NonNegativeIntegers', 'PositiveIntegers', 'NegativeIntegers',
+      'Rationals', 'Reals', 'PositiveReals', 'NonNegativeReals', 'NegativeReals',
+      'NonPositiveReals', 'ExtendedReals', 'Complexes', 'ImaginaryNumbers',
+      'Numbers', 'ExtendedComplexes', 'AlgebraicNumbers', 'TranscendentalNumbers',
+    ];
+    if (knownInfiniteSets.includes(domain.symbol)) {
+      return { status: 'non-enumerable', variable, domain, reason: 'infinite-domain' };
     }
-    return null;
+    // Unknown symbol - could be a finite set, but we can't determine
+    return { status: 'non-enumerable', variable, domain, reason: 'unknown-domain' };
   }
 
+  // Unknown domain structure
+  return { status: 'non-enumerable', variable, domain, reason: 'unrecognized-domain-type' };
+}
+
+/**
+ * Extract the finite domain from a quantifier's condition.
+ * Supports:
+ * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
+ * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
+ * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
+ * Returns null if the domain is not finite or not recognized.
+ * @deprecated Use extractFiniteDomainWithReason for better error handling
+ */
+export function extractFiniteDomain(
+  condition: BoxedExpression,
+  ce: ComputeEngine
+): { variable: string; values: BoxedExpression[] } | null {
+  const result = extractFiniteDomainWithReason(condition, ce);
+  if (result.status === 'success') {
+    return { variable: result.variable, values: result.values };
+  }
   return null;
 }