Verify pattern matching with repeated wildcards works correctly (#278)

- Verified that the pattern matching system in match.ts correctly handles
  wildcards appearing multiple times in a pattern
- The captureWildcard() function properly ensures all occurrences of a
  named wildcard (like _x) match the same expression
- Added 15 comprehensive tests in patterns.test.ts covering:
  - Simple repeated wildcards in flat structures
  - Repeated wildcards in nested function arguments
  - The specific 1/(x*ln(x)) pattern from TODO #3
  - Complex expression matching
  - Commutative reordering with repeated wildcards
  - Canonical expression matching
- Updated TODO.md to mark task #3 as completed
- Updated DONE.md with implementation details
- Updated CHANGELOG.md with testing section

https://claude.ai/code/session_01VqUF7VSwkY7RP1cA18xjv9

Co-authored-by: Claude <noreply@anthropic.com>

Author: arnog

CHANGELOG.md

@@ -18,6 +18,19 @@
   - `x - 2√x - 3 = 0` → returns `[9]` (filters out x=1)
   - `2x + 3√x - 2 = 0` → returns `[1/4]` (filters out x=4)
 
+### Testing
+
+- **Pattern Matching with Repeated Wildcards**: Added comprehensive tests
+  verifying that the pattern matching system correctly handles wildcards that
+  appear multiple times in a pattern. When a named wildcard like `_x` appears
+  in multiple positions, the matcher correctly ensures all occurrences match
+  the same expression. This works with:
+  - Nested function arguments (e.g., `['Multiply', '_x', ['Ln', '_x']]`)
+  - Multiple nesting levels (3+ levels deep)
+  - Commutative operators (handles reordering)
+  - Canonical expressions (from parsed LaTeX)
+  - Complex sub-expressions (matching entire sub-trees)
+
 ### New Features
 
 #### Subscripts and Indexing

requirements/DONE.md

@@ -934,3 +934,76 @@ ce.parse('2x + 3\\sqrt{x} - 2 = 0').solve('x')  // → [1/4]
   validate against it
 - `test/compute-engine/solve.test.ts` - Added 6 new tests in "EXTRANEOUS ROOT
   FILTERING FOR SQRT EQUATIONS" describe block
+
+---
+
+### 3. Pattern Matching with Repeated Wildcards ✅
+
+**Status:** Verified working correctly. The pattern matching system properly handles
+wildcards that appear multiple times in a pattern.
+
+**Investigated behavior:**
+
+The `captureWildcard()` function in `match.ts` (lines 37-58) correctly handles
+repeated wildcards:
+
+1. When a named wildcard (like `_x`) is first encountered, it's captured in the
+   substitution dictionary
+2. When the same wildcard is encountered again, it checks if the new expression
+   is the same as the previously captured one using `isSame()`
+3. If they match, the substitution is preserved; if not, the match fails
+
+**Examples that work correctly:**
+
+```typescript
+// Pattern with repeated wildcard
+pattern = ['Divide', 1, ['Multiply', '_x', ['Ln', '_x']]]
+expr = ['Divide', 1, ['Multiply', 'x', ['Ln', 'x']]]
+// Result: { _x: x } ✓
+
+// Pattern with 3 levels of nesting
+pattern = ['Add', '_x', ['Multiply', '_x', ['Power', '_x', 2]]]
+expr = ['Add', 'x', ['Multiply', 'x', ['Power', 'x', 2]]]
+// Result: { _x: x } ✓
+
+// Repeated wildcard with commutative operators
+pattern = ['Add', '_x', ['Ln', '_x']]
+expr = ['Add', ['Ln', 'x'], 'x']  // order swapped
+// Result: { _x: x } ✓ (handles commutative reordering)
+
+// Mismatch correctly detected
+pattern = ['Multiply', '_x', ['Ln', '_x']]
+expr = ['Multiply', 'x', ['Ln', 'y']]  // different variables
+// Result: null ✓ (correctly rejects)
+
+// Complex expression matching
+pattern = ['Add', '_x', ['Power', '_x', 2]]
+expr = ['Add', ['Add', 'a', 1], ['Power', ['Add', 'a', 1], 2]]
+// Result: { _x: ['Add', 'a', 1] } ✓ (matches complex sub-expression)
+```
+
+**Integration with antiderivative.ts:**
+
+The specific integral `∫ 1/(x·ln(x)) dx = ln|ln(x)|` is handled procedurally in
+`antiderivative.ts` (lines 1772-1800) using Case D2, which:
+
+1. Recognizes patterns like `1/(g(x)·h(x))` where `g(x) = d/dx(h(x))`
+2. For `1/(x·ln(x))`, identifies that `1/x = d/dx(ln(x))`
+3. Returns `ln|h(x)|` = `ln|ln(x)|`
+
+This procedural approach is appropriate because it requires computing derivatives
+dynamically, which cannot be expressed as a static pattern matching rule.
+
+**Files verified:**
+- `src/compute-engine/boxed-expression/match.ts` - Pattern matching logic
+- `src/compute-engine/symbolic/antiderivative.ts` - Integration patterns
+
+**Tests added:**
+- `test/compute-engine/patterns.test.ts` - Added 15 new tests in "Repeated
+  Wildcards in Nested Contexts" describe block covering:
+  - Simple repeated wildcards in flat structures
+  - Repeated wildcards in nested function arguments
+  - Repeated wildcards with Divide patterns
+  - Complex expression matching
+  - Commutative reordering with repeated wildcards
+  - Canonical expression matching

requirements/TODO.md

@@ -63,35 +63,9 @@ output.
 
 ---
 
-### 3. Pattern Matching Improvements
+### ~~3. Pattern Matching Improvements~~ ✅ COMPLETED
 
-**Problem:** Some integration patterns don't match because the pattern matching
-system has limitations with:
-
-- Same wildcard appearing multiple times (should match same expression)
-- Matching against canonicalized expressions that have been reordered
-- Complex nested patterns
-
-**Example that doesn't work:**
-
-```typescript
-// Trying to match 1/(x*ln(x)) where x appears twice
-{
-  match: ['Divide', 1, ['Multiply', '_x', ['Ln', '_x']]],
-  replace: ['Ln', ['Ln', '_x']],
-}
-```
-
-**Investigation needed:**
-
-- Review `src/compute-engine/boxed-expression/match.ts`
-- Understand how wildcard binding works
-- Consider adding "same as" constraints: `_x@1` and `_x@1` must match same expr
-
-**Files:**
-
-- `src/compute-engine/boxed-expression/match.ts`
-- `src/compute-engine/symbolic/antiderivative.ts`
+See `requirements/DONE.md` for implementation details.
 
 ---
 

test/compute-engine/patterns.test.ts

@@ -1481,3 +1481,173 @@ describe('Permutation Matching Optimization', () => {
     });
   });
 });
+
+// ============================================================================
+// REPEATED WILDCARDS IN NESTED CONTEXTS (TODO #3)
+// ============================================================================
+
+describe('Repeated Wildcards in Nested Contexts', () => {
+  // Non-canonical matching helper
+  const matchNonCanonical = (pattern, expr) => {
+    const boxedPattern = ce.box(pattern, { canonical: false });
+    const boxedExpr = ce.box(expr, { canonical: false });
+    return boxedExpr.match(boxedPattern);
+  };
+
+  describe('Simple repeated wildcards (flat structure)', () => {
+    test('_a appears twice - same value should match', () => {
+      const result = matchNonCanonical(
+        ['Add', '_a', '_a'],
+        ['Add', 'x', 'x']
+      );
+      expect(result).not.toBeNull();
+      expect(result?._a?.toString()).toBe('x');
+    });
+
+    test('_a appears twice - different values should not match', () => {
+      const result = matchNonCanonical(
+        ['Add', '_a', '_a'],
+        ['Add', 'x', 'y']
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Repeated wildcards in nested function arguments', () => {
+    test('_x in direct arg and inside Ln - same value', () => {
+      const result = matchNonCanonical(
+        ['Multiply', '_x', ['Ln', '_x']],
+        ['Multiply', 'x', ['Ln', 'x']]
+      );
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+
+    test('_x in direct arg and inside Ln - different values should not match', () => {
+      const result = matchNonCanonical(
+        ['Multiply', '_x', ['Ln', '_x']],
+        ['Multiply', 'x', ['Ln', 'y']]
+      );
+      expect(result).toBeNull();
+    });
+
+    test('_x appears at 3 different nesting levels', () => {
+      const result = matchNonCanonical(
+        ['Add', '_x', ['Multiply', '_x', ['Power', '_x', 2]]],
+        ['Add', 'x', ['Multiply', 'x', ['Power', 'x', 2]]]
+      );
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+
+    test('exp(x)*sin(x) with repeated _x', () => {
+      const result = matchNonCanonical(
+        ['Multiply', ['Exp', '_x'], ['Sin', '_x']],
+        ['Multiply', ['Exp', 'x'], ['Sin', 'x']]
+      );
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+  });
+
+  describe('Repeated wildcards with Divide patterns', () => {
+    test('1/(x*ln(x)) pattern - the TODO #3 example', () => {
+      const result = matchNonCanonical(
+        ['Divide', 1, ['Multiply', '_x', ['Ln', '_x']]],
+        ['Divide', 1, ['Multiply', 'x', ['Ln', 'x']]]
+      );
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+
+    test('1/(x*ln(x)) with different variables should not match', () => {
+      const result = matchNonCanonical(
+        ['Divide', 1, ['Multiply', '_x', ['Ln', '_x']]],
+        ['Divide', 1, ['Multiply', 'x', ['Ln', 'y']]]
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Repeated wildcards matching complex expressions', () => {
+    test('_x should match the same complex expression everywhere', () => {
+      const result = matchNonCanonical(
+        ['Add', '_x', ['Power', '_x', 2]],
+        ['Add', ['Add', 'a', 1], ['Power', ['Add', 'a', 1], 2]]
+      );
+      expect(result).not.toBeNull();
+      // _x should match ['Add', 'a', 1]
+    });
+
+    test('_x matching complex expr - mismatch should fail', () => {
+      const result = matchNonCanonical(
+        ['Add', '_x', ['Power', '_x', 2]],
+        ['Add', ['Add', 'a', 1], ['Power', ['Add', 'a', 2], 2]]
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Repeated wildcards with commutative reordering', () => {
+    test('_x + ln(_x) with Add being commutative', () => {
+      const result = matchNonCanonical(
+        ['Add', '_x', ['Ln', '_x']],
+        ['Add', ['Ln', 'x'], 'x']
+      );
+      // Add is commutative, so this should match with _x = x
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+
+    test('_x * sin(_x) with Multiply being commutative', () => {
+      const result = matchNonCanonical(
+        ['Multiply', '_x', ['Sin', '_x']],
+        ['Multiply', ['Sin', 'x'], 'x']
+      );
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+  });
+
+  describe('Repeated wildcards with CANONICAL expressions', () => {
+    test('1/(x*ln(x)) with canonical expression', () => {
+      // Pattern is non-canonical (structural)
+      const pattern = ce.box(['Divide', 1, ['Multiply', '_x', ['Ln', '_x']]], {
+        canonical: false,
+      });
+      // Expression is canonical (what you get from parsing)
+      const expr = ce.parse('\\frac{1}{x \\ln x}');
+
+      const result = expr.match(pattern);
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+
+    test('exp(x)*sin(x) canonical expression', () => {
+      // e^x becomes Power(ExponentialE, x), which doesn't match Exp(_x)
+      // So this pattern needs to account for the canonical form
+      const pattern = ce.box(
+        ['Multiply', ['Power', 'ExponentialE', '_x'], ['Sin', '_x']],
+        { canonical: false }
+      );
+      const expr = ce.parse('e^x \\sin x');
+
+      const result = expr.match(pattern);
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+
+    test('Repeated wildcard fails when canonical order differs', () => {
+      // Multiply may reorder operands, so [x, ln(x)] might become [ln(x), x]
+      // The pattern matching should still work due to commutativity handling
+      const pattern = ce.box(['Multiply', '_x', ['Ln', '_x']], {
+        canonical: false,
+      });
+      const expr = ce.parse('x \\ln x');
+
+      const result = expr.match(pattern);
+      expect(result).not.toBeNull();
+      expect(result?._x?.toString()).toBe('x');
+    });
+  });
+});