feat: Add support for braced \mathopen and \mathclose delimiters in LaTeX parser

Author: arnog

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ### New Features
 
+- **`\mathopen` and `\mathclose` Support**: The LaTeX parser now supports
+  `\mathopen` and `\mathclose` delimiter prefixes for matchfix operators. This
+  allows parsing expressions like `\mathopen(a, b\mathclose)` and the braced
+  form `\mathopen{(}a, b\mathclose{)}`. These commands are commonly used in
+  LaTeX for explicit delimiter spacing control.
+
 - **Custom Operator Compilation**: The `compile()` method now supports overriding
   operators to use function calls instead of native operators. This enables
   compilation of vector/matrix operations and custom domain-specific languages.

requirements/DONE.md

@@ -1799,3 +1799,51 @@ e3.solve(['a', 'b', 'c', 'd']);
   for under-determined systems
 - `test/compute-engine/solve.test.ts` - Added 5 new tests for parametric solutions
   and updated existing test to expect parametric result
+
+---
+
+### 33. Polynomial Factoring ✅
+
+**IMPLEMENTED:** Polynomial factoring capability for perfect square trinomials,
+difference of squares, and quadratic factoring. Enables simplification of
+expressions like `√(x²+2x+1)` → `|x+1|`. Fixes issue #180.
+
+**Factoring functions implemented:**
+
+- `factorPerfectSquare()` - Detects a² ± 2ab + b² → (a±b)²
+- `factorDifferenceOfSquares()` - Detects a² - b² → (a-b)(a+b)
+- `factorQuadratic()` - Factors ax² + bx + c when roots are rational
+- `factorPolynomial()` - Combined entry point that tries all strategies
+
+**Examples that now work:**
+
+```typescript
+// Perfect square trinomials in sqrt
+ce.parse('\\sqrt{x^2+2x+1}').simplify().latex;      // → "|x+1|"
+ce.parse('\\sqrt{a^2+2ab+b^2}').simplify().latex;   // → "|a+b|"
+ce.parse('\\sqrt{a^2-2ab+b^2}').simplify().latex;   // → "|a-b|"
+ce.parse('\\sqrt{4x^2-12x+9}').simplify().latex;    // → "|2x-3|"
+
+// Direct factoring
+factorPolynomial(ce.parse('x^2+5x+6'), 'x').latex;  // → "(x+2)(x+3)"
+factorPolynomial(ce.parse('x^2-4'), 'x').latex;     // → "(x-2)(x+2)"
+factorPolynomial(ce.parse('2x^2-8'), 'x').latex;    // → "2(x-2)(x+2)"
+
+// Rational expression simplification
+ce.parse('\\frac{x^2-1}{x-1}').simplify().latex;    // → "x+1"
+```
+
+**Integration with sqrt simplification:**
+
+The `simplify-power.ts` file calls `factorPerfectSquare()` when simplifying
+`Sqrt` of `Add` expressions, enabling automatic simplification of perfect
+square trinomials inside square roots.
+
+**Files modified:**
+
+- `src/compute-engine/boxed-expression/factor.ts` - Added `factorPerfectSquare()`,
+  `factorDifferenceOfSquares()`, `factorQuadratic()`, `factorPolynomial()`, and
+  helper `extractSquareRoot()`
+- `src/compute-engine/symbolic/simplify-power.ts` - Integrated perfect square
+  and difference of squares detection in Sqrt simplification
+- `test/compute-engine/factor.test.ts` - Comprehensive test suite with 30+ tests

requirements/TODO.md

@@ -644,172 +644,9 @@ See `requirements/DONE.md` for implementation details.
 
 ## Polynomial Operations
 
-### 33. Polynomial Factoring
+### ~~33. Polynomial Factoring~~ ✅ COMPLETED
 
-**Problem:** The system lacks polynomial factoring capability to convert expanded
-polynomials into factored forms. This prevents simplification of expressions like
-`√(x²+2x+1)` which should factor to `√((x+1)²)` and simplify to `|x+1|`.
-
-**Related issue:** [#180](https://github.com/cortex-js/compute-engine/issues/180)
-- "Factoring before trying to simplify"
-
-**Current behavior:**
-
-```typescript
-// Factored form works
-ce.parse('\\sqrt{(x+1)^2}').simplify().latex;
-// → "\vert x+1\vert"  ✓
-
-// Expanded form doesn't factor first
-ce.parse('\\sqrt{x^2+2x+1}').simplify().latex;
-// → "\sqrt{x^2+2x+1}"  ✗ (should recognize perfect square)
-
-// Rational simplification works (partial fix in #180)
-ce.parse('\\frac{x}{x^2-x}').simplify().latex;
-// → "\frac{1}{x-1}"  ✓ (factors denominator for cancellation)
-```
-
-**Expected behavior:**
-
-```typescript
-// Perfect square trinomials
-ce.parse('\\sqrt{x^2+2x+1}').simplify().latex;
-// → "\vert x+1\vert"
-
-ce.parse('\\sqrt{a^2+2ab+b^2}').simplify().latex;
-// → "\vert a+b\vert"
-
-ce.parse('\\sqrt{a^2-2ab+b^2}').simplify().latex;
-// → "\vert a-b\vert"
-
-// General quadratic factoring
-ce.parse('x^2+5x+6').factor().latex;
-// → "(x+2)(x+3)"
-
-ce.parse('2x^2-8').factor().latex;
-// → "2(x-2)(x+2)"
-```
-
-**Implementation approach:**
-
-1. **Add `factor()` method to BoxedExpression:**
-   - Extend existing `factor()` in `src/compute-engine/boxed-expression/factor.ts`
-   - Current implementation only factors out common coefficients/terms
-   - Need to add polynomial factorization algorithms
-
-2. **Factoring algorithms to implement:**
-   - **Perfect square detection:** `a²+2ab+b²` → `(a+b)²`, `a²-2ab+b²` → `(a-b)²`
-   - **Difference of squares:** `a²-b²` → `(a-b)(a+b)`
-   - **Quadratic formula factoring:** For `ax²+bx+c`, use roots to construct factors
-   - **Common factor extraction:** `6x²+9x` → `3x(2x+3)` (already implemented)
-   - **Rational root theorem:** For higher-degree polynomials with integer coefficients
-   - **Kronecker's method:** General factorization over integers (optional, for completeness)
-
-3. **Perfect square trinomial detection (priority for issue #180):**
-   ```typescript
-   function isPerfectSquare(expr: BoxedExpression): BoxedExpression | null {
-     // For Add with 3 terms
-     if (expr.operator !== 'Add' || expr.ops.length !== 3) return null;
-
-     // Check pattern: a² + 2ab + b² or a² - 2ab + b²
-     // Extract terms, identify squares and cross term
-     // Return (a+b)² or (a-b)² if match found
-   }
-   ```
-
-4. **Integration with simplification:**
-   - Modify `simplifyPower()` in `src/compute-engine/symbolic/simplify-power.ts`
-   - Before checking `sqrt(x^2)` patterns, try factoring the argument
-   - Add check around line 126 (Sqrt operator handling):
-
-   ```typescript
-   if (op === 'Sqrt') {
-     const arg = x.op1;
-     if (!arg) return undefined;
-
-     // Try factoring first for perfect squares
-     if (arg.operator === 'Add') {
-       const factored = factorPerfectSquare(arg);
-       if (factored?.operator === 'Power' && factored.op2?.is(2)) {
-         // Found perfect square, apply sqrt(x^2) -> |x| rule
-         return {
-           value: ce._fn('Abs', [factored.op1]),
-           because: 'sqrt(perfect square trinomial) -> |factor|'
-         };
-       }
-     }
-
-     // ... existing sqrt simplification rules
-   }
-   ```
-
-5. **IMPORTANT - Recursion prevention:**
-   - Factoring functions should NOT call `.simplify()` on results
-   - Follow pattern from `polynomialDivide()` and other polynomial operations
-   - Return canonical expressions, let caller decide if simplification needed
-   - See `CLAUDE.md` "Simplification and Recursion Prevention" section
-
-**Use cases:**
-
-1. **Square root simplification** (issue #180):
-   - `√(x²+2x+1)` → `|x+1|`
-   - `√(4x²-12x+9)` → `|2x-3|`
-
-2. **Rational expression simplification:**
-   - `(x²-1)/(x+1)` → `x-1` (currently requires already factored form)
-   - `(x²+5x+6)/(x+2)` → `x+3`
-
-3. **Equation solving:**
-   - `x²+5x+6 = 0` → factor → `(x+2)(x+3) = 0` → `x = -2` or `x = -3`
-
-4. **Partial fraction decomposition:**
-   - Requires factored denominators
-
-**Files to modify:**
-
-- `src/compute-engine/boxed-expression/factor.ts` - Add polynomial factoring
-- `src/compute-engine/symbolic/simplify-power.ts` - Use factoring in sqrt simplification
-- `src/compute-engine/boxed-expression/polynomials.ts` - Add helper functions if needed
-- `src/compute-engine/boxed-expression/abstract-boxed-expression.ts` - Ensure `.factor()` method exists
-
-**Tests to add:**
-
-```typescript
-// test/compute-engine/factor.test.ts
-describe('Polynomial factoring', () => {
-  test('perfect square trinomials', () => {
-    expect(parse('x^2+2x+1').factor()).toMatchInlineSnapshot(`["Square", ["Add", "x", 1]]`);
-    expect(parse('a^2+2ab+b^2').factor()).toMatchInlineSnapshot(`["Square", ["Add", "a", "b"]]`);
-  });
-
-  test('difference of squares', () => {
-    expect(parse('x^2-4').factor()).toMatchInlineSnapshot(`["Multiply", ["Add", "x", -2], ["Add", "x", 2]]`);
-  });
-
-  test('quadratic with roots', () => {
-    expect(parse('x^2+5x+6').factor()).toMatchInlineSnapshot(`["Multiply", ["Add", "x", 2], ["Add", "x", 3]]`);
-  });
-});
-
-// test/compute-engine/simplify.test.ts - add to existing tests
-test('sqrt of perfect square trinomial', () => {
-  expect(parse('\\sqrt{x^2+2x+1}').simplify()).toMatchInlineSnapshot(`["Abs", ["Add", "x", 1]]`);
-  expect(parse('\\sqrt{a^2-2ab+b^2}').simplify()).toMatchInlineSnapshot(`["Abs", ["Add", "a", ["Negate", "b"]]]`);
-});
-```
-
-**Implementation priority:**
-
-1. **High priority:** Perfect square trinomial detection for sqrt simplification (fixes issue #180 cases)
-2. **Medium priority:** General quadratic factoring with rational roots
-3. **Low priority:** Higher-degree polynomial factoring (Kronecker's method, etc.)
-
-**References:**
-
-- Issue #180: https://github.com/cortex-js/compute-engine/issues/180
-- Current factor implementation: `src/compute-engine/boxed-expression/factor.ts`
-- Sqrt simplification: `src/compute-engine/symbolic/simplify-power.ts:124-254`
-- Polynomial utilities: `src/compute-engine/boxed-expression/polynomials.ts`
+See `requirements/DONE.md` for implementation details.
 
 ---
 

src/compute-engine/latex-syntax/parse.ts

@@ -841,6 +841,11 @@ export class _Parser implements Parser {
     const closePrefix = OPEN_DELIMITER_PREFIX[this.peek];
     if (closePrefix) this.nextToken();
 
+    // Handle braced form: \mathopen{(} or \mathopen{\lbrack}
+    // After consuming the prefix, check if there's a braced delimiter
+    const hasBracedDelimiter = closePrefix && this.peek === '<{>';
+    if (hasBracedDelimiter) this.nextToken(); // consume the opening brace
+
     // If the delimiters are token arrays, look specifically for those
     if (Array.isArray(open)) {
       // If the open trigger is an array, the close trigger must be an array too
@@ -858,6 +863,12 @@ export class _Parser implements Parser {
         const matchedToken = this.nextToken();
         const useLatexCommand = matchedToken.startsWith('\\');
 
+        // Consume closing brace if we had a braced delimiter \mathopen{(}
+        if (hasBracedDelimiter && !this.match('<}>')) {
+          this.index = start;
+          return false;
+        }
+
         // Find the corresponding close token variant
         const closeTokens = DELIMITER_SHORTHAND[close[0] as string] ?? [
           close[0],
@@ -866,8 +877,11 @@ export class _Parser implements Parser {
           useLatexCommand ? t.startsWith('\\') : !t.startsWith('\\')
         ) ?? closeTokens[0]) as LatexToken;
 
+        // Build the close boundary: for braced form, expect \mathclose{)}
         const closeBoundary = closePrefix
-          ? [closePrefix, closeToken]
+          ? hasBracedDelimiter
+            ? [closePrefix, '<{>', closeToken, '<}>']
+            : [closePrefix, closeToken]
           : [closeToken];
         this.addBoundary(closeBoundary);
         return true;
@@ -901,11 +915,23 @@ export class _Parser implements Parser {
 
     open = this.nextToken() as Delimiter;
 
+    // Consume closing brace if we had a braced delimiter \mathopen{(}
+    if (hasBracedDelimiter && !this.match('<}>')) {
+      this.index = start;
+      return false;
+    }
+
     // If we are using a shorthand delimiter, we need to add the
     // corresponding close delimiter.
     close = CLOSE_DELIMITER[open] ?? close;
 
-    this.addBoundary(closePrefix ? [closePrefix, close] : [close]);
+    // Build the close boundary: for braced form, expect \mathclose{)}
+    const closeBoundary = closePrefix
+      ? hasBracedDelimiter
+        ? [closePrefix, '<{>', close, '<}>']
+        : [closePrefix, close]
+      : [close];
+    this.addBoundary(closeBoundary);
     return true;
   }
 
@@ -1536,7 +1562,10 @@ export class _Parser implements Parser {
     // Use the matchfix index for fast lookup of relevant definitions
     // If there's a delimiter prefix like \left, \mathopen, peek ahead to get the actual delimiter
     const hasPrefix = OPEN_DELIMITER_PREFIX[currentToken];
-    const lookupToken = hasPrefix ? this._tokens[this.index + 1] : currentToken;
+    let lookupToken = hasPrefix ? this._tokens[this.index + 1] : currentToken;
+    // Handle braced form: \mathopen{(} - skip past the brace to get the actual delimiter
+    if (hasPrefix && lookupToken === '<{>')
+      lookupToken = this._tokens[this.index + 2];
 
     // Get only the matchfix defs that could match this opening token
     // Note: some tokens (like |) may match multiple defs (|| and |)

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

@@ -1,4 +1,5 @@
 import { Expression } from '../../../src/math-json/types.ts';
+import { ComputeEngine } from '../../../src/compute-engine';
 import { engine as ce, evaluate, latex } from '../../utils';
 
 describe('SUM parsing', () => {
@@ -393,7 +394,7 @@ describe('EL-3: Condition/Filter Support in Element Expressions', () => {
   // filters the values from the set
 
   test('parsing Element with Greater condition', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     const expr = ce2.parse('\\sum_{n \\in S, n > 0} n');
     // Should parse with condition attached to Element
     expect(expr.json).toMatchObject([
@@ -404,7 +405,7 @@ describe('EL-3: Condition/Filter Support in Element Expressions', () => {
   });
 
   test('parsing Element with GreaterEqual condition', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     const expr = ce2.parse('\\sum_{n \\in S, n \\ge 2} n');
     expect(expr.json).toMatchObject([
       'Sum',
@@ -414,7 +415,7 @@ describe('EL-3: Condition/Filter Support in Element Expressions', () => {
   });
 
   test('parsing Element with Less condition', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     const expr = ce2.parse('\\sum_{n \\in S, n < 0} n');
     expect(expr.json).toMatchObject([
       'Sum',
@@ -424,39 +425,39 @@ describe('EL-3: Condition/Filter Support in Element Expressions', () => {
   });
 
   test('sum with condition n > 0 filters positive values', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     ce2.assign('S', ce2.box(['Set', 1, 2, 3, -1, -2]));
     const expr = ce2.parse('\\sum_{n \\in S, n > 0} n');
     // Should sum only 1+2+3 = 6
     expect(expr.evaluate().json).toBe(6);
   });
 
   test('sum with condition n >= 2 filters values >= 2', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     ce2.assign('S', ce2.box(['Set', 1, 2, 3, 4, 5, -1, -2]));
     const expr = ce2.parse('\\sum_{n \\in S, n \\ge 2} n');
     // Should sum only 2+3+4+5 = 14
     expect(expr.evaluate().json).toBe(14);
   });
 
   test('sum with condition n < 0 filters negative values', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     ce2.assign('S', ce2.box(['Set', 1, 2, 3, -1, -2, -3]));
     const expr = ce2.parse('\\sum_{n \\in S, n < 0} n');
     // Should sum only -1-2-3 = -6
     expect(expr.evaluate().json).toBe(-6);
   });
 
   test('product with condition n > 0', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     ce2.assign('S', ce2.box(['Set', 1, 2, 3, 4, -1, -2]));
     const expr = ce2.parse('\\prod_{n \\in S, n > 0} n');
     // Should multiply only 1*2*3*4 = 24
     expect(expr.evaluate().json).toBe(24);
   });
 
   test('condition with explicit inline set', () => {
-    const ce2 = new (ce.constructor as typeof ce.constructor)();
+    const ce2 = new ComputeEngine();
     const expr = ce2.box([
       'Sum',
       'n',