feat: implement conversion of known infinite integer sets to Limits form and add corresponding tests

Author: arnog

CHANGELOG.md

@@ -91,11 +91,19 @@
     - `["Interval", ["Open", 0], 5]` → iterates 1, 2, 3, 4, 5 (excludes 0)
     - `["Interval", 1, ["Open", 6]]` → iterates 1, 2, 3, 4, 5 (excludes 6)
 
+  - **Infinite series with Element notation**: Known infinite integer sets are
+    converted to their equivalent Limits form and iterated (capped at 1,000,000):
+    - `NonNegativeIntegers` (ℕ₀) → iterates from 0, like `\sum_{n=0}^{\infty}`
+    - `PositiveIntegers` (ℤ⁺) → iterates from 1, like `\sum_{n=1}^{\infty}`
+    - Convergent series produce numeric approximations:
+      `\sum_{n \in \Z^+} \frac{1}{n^2}` → `≈1.6449` (close to π²/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:
+    (unknown symbol, non-iterable infinite set, or symbolic bounds), the expression
+    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 \Z} n` → stays symbolic (bidirectional, can't forward iterate)
+    - `\sum_{x \in \R} f(x)` → stays symbolic (non-countable)
     - `\sum_{n \in [1,a]} n` with symbolic bound → stays symbolic
     - Previously these would all return `NaN` with no explanation
 

src/compute-engine/library/utils.ts

@@ -4,6 +4,34 @@ import { MAX_ITERATION } from '../numerics/numeric';
 import { fromRange, reduceCollection } from './collections';
 import { extractFiniteDomainWithReason, ExtractDomainResult } from './logic-analysis';
 
+/**
+ * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
+ * Returns undefined if the set cannot be converted to a Limits form.
+ *
+ * Mappings:
+ * - NonNegativeIntegers (ℕ₀) → [0, ∞)
+ * - PositiveIntegers (ℤ⁺) → [1, ∞)
+ * - NegativeIntegers (ℤ⁻) → Not supported (would need negative direction)
+ * - Integers (ℤ) → Not supported (bidirectional)
+ * - Other sets (Reals, Complexes, etc.) → Not supported (non-integer)
+ */
+export function convertInfiniteSetToLimits(
+  domainSymbol: string
+): { lower: number; upper: number; isFinite: false } | undefined {
+  switch (domainSymbol) {
+    case 'NonNegativeIntegers':
+      // ℕ₀ = {0, 1, 2, 3, ...}
+      return { lower: 0, upper: MAX_ITERATION, isFinite: false };
+    case 'PositiveIntegers':
+      // ℤ⁺ = {1, 2, 3, ...}
+      return { lower: 1, upper: 1 + MAX_ITERATION, isFinite: false };
+    default:
+      // NegativeIntegers, Integers, Reals, Complexes, etc. cannot be
+      // converted to a simple forward iteration
+      return undefined;
+  }
+}
+
 export type IndexingSet = {
   index: string | undefined;
   lower: number;
@@ -476,6 +504,23 @@ function* reduceElementIndexingSets<T>(
       }
 
       if (domainResult.status === 'non-enumerable') {
+        // EL-4: Check if this is a known infinite integer set that can be
+        // converted to Limits form for iteration
+        if (
+          domainResult.reason === 'infinite-domain' &&
+          domainResult.domain?.symbol
+        ) {
+          const limits = convertInfiniteSetToLimits(domainResult.domain.symbol);
+          if (limits) {
+            // Convert to Limits and continue with iteration
+            limitsSets.push({
+              index: domainResult.variable,
+              ...limits,
+            });
+            continue; // Process next index, don't return early
+          }
+        }
+
         // Domain exists but cannot be enumerated - keep expression symbolic
         if (returnReason) {
           return {

test/compute-engine/latex-syntax/arithmetic.test.ts

@@ -402,35 +402,31 @@ describe('EL-5: Non-enumerable domains stay symbolic', () => {
     expect(result.isNaN).not.toBe(true);
   });
 
-  test('sum over NonNegativeIntegers (infinite set) stays symbolic', () => {
-    const expr = ce.box(['Sum', 'n', ['Element', 'n', 'NonNegativeIntegers']]);
-    const result = expr.evaluate();
-    expect(result.operator).toBe('Sum');
-    expect(result.isNaN).not.toBe(true);
-  });
+  // EL-4: NonNegativeIntegers and PositiveIntegers can be converted to Limits
+  // and will iterate (capped at MAX_ITERATION), so they evaluate to numbers
+  // Other infinite sets (Integers, Reals) that can't be iterated stay symbolic
 
   test('sum over Integers (infinite set) stays symbolic', () => {
+    // Integers is bidirectional, cannot be converted to forward iteration
     const expr = ce.box(['Sum', 'n', ['Element', 'n', 'Integers']]);
     const result = expr.evaluate();
     expect(result.operator).toBe('Sum');
     expect(result.isNaN).not.toBe(true);
   });
 
   test('sum over Reals (infinite set) stays symbolic', () => {
+    // Reals is non-countable, cannot be iterated
     const expr = ce.box(['Sum', 'x', ['Element', 'x', 'Reals']]);
     const result = expr.evaluate();
     expect(result.operator).toBe('Sum');
     expect(result.isNaN).not.toBe(true);
   });
 
-  test('product over PositiveIntegers (infinite set) stays symbolic', () => {
-    const expr = ce.box([
-      'Product',
-      'k',
-      ['Element', 'k', 'PositiveIntegers'],
-    ]);
+  test('sum over NegativeIntegers (infinite set) stays symbolic', () => {
+    // NegativeIntegers goes in the negative direction, can't be forward iterated
+    const expr = ce.box(['Sum', 'n', ['Element', 'n', 'NegativeIntegers']]);
     const result = expr.evaluate();
-    expect(result.operator).toBe('Product');
+    expect(result.operator).toBe('Sum');
     expect(result.isNaN).not.toBe(true);
   });
 
@@ -451,6 +447,54 @@ describe('EL-5: Non-enumerable domains stay symbolic', () => {
   });
 });
 
+describe('EL-4: Infinite series with Element notation', () => {
+  // EL-4: NonNegativeIntegers and PositiveIntegers are converted to Limits form
+  // and iterated (capped at MAX_ITERATION), behaving like traditional bounds notation
+
+  test('sum over NonNegativeIntegers evaluates (converges to partial sum)', () => {
+    // Sum n from 0 to MAX_ITERATION - should give a numeric result (triangular number approximation)
+    // Note: This test verifies the behavior change, not the exact value
+    const expr = ce.box(['Sum', 'n', ['Element', 'n', 'NonNegativeIntegers']]);
+    const result = expr.evaluate();
+    // Should be a Number, not remain as Sum
+    expect(result.isNumber).toBe(true);
+    expect(result.operator).not.toBe('Sum');
+    expect(result.isNaN).not.toBe(true);
+  }, 15000); // Allow 15 seconds for iteration
+
+  test('product over PositiveIntegers evaluates (converges to partial product)', () => {
+    // Product k from 1 to MAX_ITERATION - should give a numeric result
+    const expr = ce.box([
+      'Product',
+      'k',
+      ['Element', 'k', 'PositiveIntegers'],
+    ]);
+    const result = expr.evaluate();
+    // Should be a Number, not remain as Product
+    expect(result.isNumber).toBe(true);
+    expect(result.operator).not.toBe('Product');
+    expect(result.isNaN).not.toBe(true);
+  }, 15000); // Allow 15 seconds for iteration
+
+  test('convergent series over NonNegativeIntegers gives reasonable approximation', () => {
+    // Sum 1/n^2 from 1 to infinity approaches π²/6 ≈ 1.6449
+    // Using PositiveIntegers to avoid division by zero
+    const expr = ce.box([
+      'Sum',
+      ['Power', 'n', -2],
+      ['Element', 'n', 'PositiveIntegers'],
+    ]);
+    const result = expr.evaluate();
+    expect(result.isNumber).toBe(true);
+    // Should be close to π²/6 ≈ 1.6449
+    // .re gives us the numeric value as a number
+    const value = result.re;
+    expect(typeof value).toBe('number');
+    expect(value).toBeGreaterThan(1.6);
+    expect(value).toBeLessThan(1.7);
+  }, 30000); // Allow 30 seconds for this computation
+});
+
 describe('PRODUCT', () => {
   test('k is an Integer (as the index) and used a a Number (in the fraction)', () => {
     expect(evaluate(`\\prod_{k=1}^{10}\\frac{k}{2}`)).toMatchInlineSnapshot(