feat: add simplification rules for sum and product with symbolic bounds, enhance LaTeX parsing for gcd and lcm

Author: arnog

src/compute-engine/library/arithmetic.ts

@@ -1484,7 +1484,8 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           ),
           options.engine._timeRemaining
         );
-        return result ?? options.engine.NaN;
+        // Evaluate the accumulated result to combine numeric factors
+        return result?.evaluate() ?? options.engine.NaN;
       },
 
       evaluateAsync: async (ops, options) => {
@@ -1498,7 +1499,7 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           options.engine._timeRemaining,
           options.signal
         );
-        return result ?? options.engine.NaN;
+        return result?.evaluate() ?? options.engine.NaN;
       },
     },
 
@@ -1525,7 +1526,9 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           ),
           engine._timeRemaining
         );
-        return result ?? engine.NaN;
+        // Evaluate the accumulated result to combine numeric terms
+        // e.g., 3x + 1 + 2 + 3 → 3x + 6
+        return result?.evaluate() ?? engine.NaN;
       },
 
       evaluateAsync: async (xs, { engine, signal }) => {
@@ -1539,7 +1542,7 @@ export const ARITHMETIC_LIBRARY: SymbolDefinitions[] = [
           engine._timeRemaining,
           signal
         );
-        return result ?? engine.NaN;
+        return result?.evaluate() ?? engine.NaN;
       },
     },
   },

src/compute-engine/symbolic/simplify-rules.ts

@@ -262,11 +262,91 @@ export const SIMPLIFY_RULES: Rule[] = [
     };
   },
   //
-  // Product, Sum
+  // Sum simplification
   //
   (x): RuleStep | undefined => {
-    if (x.operator === 'Max') {
+    if (x.operator !== 'Sum') return undefined;
+
+    const body = x.op1;
+    const limits = x.op2;
+    if (!body || !limits || limits.operator !== 'Limits') return undefined;
+
+    const index = limits.op1?.symbol;
+    const lower = limits.op2;
+    const upper = limits.op3;
+    if (!index || !lower || !upper) return undefined;
+
+    const ce = x.engine;
+    const bodyUnknowns = new Set(body.unknowns);
+
+    // If body doesn't depend on index: Sum(c, [n, a, b]) → (b - a + 1) * c
+    if (!bodyUnknowns.has(index)) {
+      const count = upper.sub(lower).add(ce.One).simplify();
+      return {
+        value: count.mul(body.simplify()),
+        because: 'sum of constant',
+      };
+    }
+
+    // If body is just the index: Sum(n, [n, 1, b]) → b * (b + 1) / 2
+    if (body.symbol === index && lower.is(1)) {
+      // Triangular number formula
+      const result = upper.mul(upper.add(ce.One)).div(2);
+      return { value: result.simplify(), because: 'triangular number' };
+    }
+
+    // If body is index squared: Sum(n^2, [n, 1, b]) → b(b+1)(2b+1)/6
+    if (
+      body.operator === 'Power' &&
+      body.op1?.symbol === index &&
+      body.op2?.is(2) &&
+      lower.is(1)
+    ) {
+      // Sum of squares formula: b(b+1)(2b+1)/6
+      // Note: Don't simplify() here as the expanded form is more expensive
+      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' };
+    }
+
+    return undefined;
+  },
+
+  //
+  // Product simplification
+  //
+  (x): RuleStep | undefined => {
+    if (x.operator !== 'Product') return undefined;
+
+    const body = x.op1;
+    const limits = x.op2;
+    if (!body || !limits || limits.operator !== 'Limits') return undefined;
+
+    const index = limits.op1?.symbol;
+    const lower = limits.op2;
+    const upper = limits.op3;
+    if (!index || !lower || !upper) return undefined;
+
+    const ce = x.engine;
+    const bodyUnknowns = new Set(body.unknowns);
+
+    // If body doesn't depend on index: Product(c, [n, a, b]) → c^(b - a + 1)
+    if (!bodyUnknowns.has(index)) {
+      const count = upper.sub(lower).add(ce.One).simplify();
+      return {
+        value: body.simplify().pow(count),
+        because: 'product of constant',
+      };
+    }
+
+    // If body is just the index: Product(n, [n, 1, b]) → b!
+    if (body.symbol === index && lower.is(1)) {
+      return {
+        value: ce.function('Factorial', [upper]),
+        because: 'factorial',
+      };
     }
+
     return undefined;
   },
 

test/compute-engine/arithmetic.test.ts

@@ -3,6 +3,7 @@ import { check, checkJson, engine } from '../utils';
 const ce = engine;
 
 ce.assign('z', ['Complex', 0, 1]);
+ce.declare('b', 'integer'); // Used in Sum/Product simplification tests
 
 describe('CONSTANTS', () => {
   test(`ExponentialE`, () =>
@@ -737,6 +738,25 @@ describe('SUM', () => {
         .simplify()
         .toString()
     ).toMatchInlineSnapshot(`3x + 6`));
+
+  // Simplification of Sum with symbolic bounds
+  it('should simplify sum of constant with symbolic bounds', () => {
+    expect(
+      ce.parse('\\sum_{n=1}^{b}(x)').simplify().toString()
+    ).toMatchInlineSnapshot(`b * x`);
+  });
+
+  it('should simplify sum of index (triangular number)', () => {
+    expect(
+      ce.parse('\\sum_{n=1}^{b}(n)').simplify().toString()
+    ).toMatchInlineSnapshot(`1/2 * (b^2 + b)`);
+  });
+
+  it('should simplify sum of index squared', () => {
+    expect(
+      ce.parse('\\sum_{n=1}^{b}(n^2)').simplify().toString()
+    ).toMatchInlineSnapshot(`1/3 * b^3 + 1/2 * b^2 + 1/6 * b`);
+  });
 });
 
 describe('PRODUCT', () => {
@@ -763,6 +783,19 @@ describe('PRODUCT', () => {
     expect(
       ce.parse('\\prod_{n=1}^{3}(n \\cdot x)').evaluate().toString()
     ).toMatchInlineSnapshot(`6x^3`));
+
+  // Simplification of Product with symbolic bounds
+  it('should simplify product of constant with symbolic bounds', () => {
+    expect(
+      ce.parse('\\prod_{n=1}^{b}(x)').simplify().toString()
+    ).toMatchInlineSnapshot(`x^b`);
+  });
+
+  it('should simplify product of index (factorial)', () => {
+    expect(
+      ce.parse('\\prod_{n=1}^{b}(n)').simplify().toString()
+    ).toMatchInlineSnapshot(`b!`);
+  });
 });
 
 describe('GCD/LCM', () => {

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

@@ -231,6 +231,40 @@ describe('PRODUCT', () => {
   });
 });
 
+describe('GCD/LCM parsing', () => {
+  test('\\gcd with \\left( \\right) delimiters', () => {
+    expect(ce.parse('\\gcd\\left(24,37\\right)')).toMatchInlineSnapshot(
+      `["GCD", 24, 37]`
+    );
+  });
+
+  test('\\gcd with regular parentheses', () => {
+    expect(ce.parse('\\gcd(24,37)')).toMatchInlineSnapshot(`["GCD", 24, 37]`);
+  });
+
+  test('\\operatorname{gcd}', () => {
+    expect(ce.parse('\\operatorname{gcd}(24,37)')).toMatchInlineSnapshot(
+      `["GCD", 24, 37]`
+    );
+  });
+
+  test('\\lcm with \\left( \\right) delimiters', () => {
+    expect(ce.parse('\\lcm\\left(24,37\\right)')).toMatchInlineSnapshot(
+      `["LCM", 24, 37]`
+    );
+  });
+
+  test('\\lcm with regular parentheses', () => {
+    expect(ce.parse('\\lcm(24,37)')).toMatchInlineSnapshot(`["LCM", 24, 37]`);
+  });
+
+  test('\\operatorname{lcm}', () => {
+    expect(ce.parse('\\operatorname{lcm}(24,37)')).toMatchInlineSnapshot(
+      `["LCM", 24, 37]`
+    );
+  });
+});
+
 describe('POWER', () => {
   test('Power Invalid forms', () => {
     expect(latex(['Power'])).toMatchInlineSnapshot(