arch: support non-strict LaTeX parsing (i.e. ASCIIMath/Typst-like)

Author: arnog

requirements/OEIS.md

@@ -3,12 +3,18 @@
 [!] Need to think more about MathJSON API. What does "ClosedForm" return? Is it
 a function? Or is there such a think as a "Series" type?
 
+**✅ UPDATE (2026)**: The LaTeX parser now has a `strict: false` option that accepts Math-ASCII/Typst-like syntax (e.g., `sin(x)`, `x^(n+1)`, `a_(k+m)`). This **may eliminate the need for a separate ASCII Math parser** for OEIS formulas. See [LaTeX Parser Non-Strict Mode](#latex-parser-non-strict-mode) section for details.
+
 ## Summary
 
 Add the ability to parse OEIS formula notation and reconstruct usable sequence
-definitions. This is achieved by creating an **ASCII Math parser** (inverse of
+definitions. This can be achieved through two approaches:
+
+**Option A (Original Plan)**: Create an **ASCII Math parser** (inverse of
 the existing `toAsciiMath()` serializer), with OEIS support as a thin wrapper.
 
+**Option B (Simplified)**: Leverage the LaTeX parser's `strict: false` mode which already handles most ASCII Math/OEIS notation, reducing implementation complexity.
+
 ## Approach
 
 **Strategy**: Build an ASCII Math parser, use it for OEIS formulas
@@ -44,10 +50,49 @@ ASCII Math string. We create the inverse: ASCII Math string → BoxedExpression.
 
 The main transformation needed for OEIS: `a(n-1)` → `a_(n-1)`
 
+## LaTeX Parser Non-Strict Mode
+
+**UPDATE**: The LaTeX parser now supports a `strict: false` option that accepts
+Math-ASCII/Typst-like syntax, which overlaps significantly with OEIS notation:
+
+```typescript
+ce.parse('sin(x)^(n+1)', { strict: false })
+// Accepts:
+// - Parentheses for superscripts/subscripts: x^(n+1), a_(k+m)
+// - Bare function names: sin(x), cos(x), log(x), sqrt(x), etc.
+// - Division with slash: (n+1)/b
+
+// Supported bare functions:
+// Trig: sin, cos, tan, cot, sec, csc
+// Hyperbolic: sinh, cosh, tanh, coth, sech, csch
+// Inverse: arcsin, arccos, arctan, asin, acos, atan
+// Logarithmic: log, ln, exp, lg, lb
+// Other: sqrt, abs, floor, ceil, round, max, min, gcd, lcm
+```
+
+This means we can potentially **leverage the LaTeX parser in non-strict mode**
+for OEIS formula parsing instead of building a separate ASCII Math parser,
+reducing implementation complexity.
+
+**Benefits:**
+
+- Reuses existing, well-tested parser infrastructure
+- Handles operator precedence, function calls, parentheses automatically
+- Already integrated with MathJSON conversion
+- Reduces maintenance burden (one parser instead of two)
+
+**Considerations:**
+
+- Still need OEIS-specific pre-processing for `a(n)` → `a_n` notation
+- May need minor extensions for OEIS-specific patterns (e.g., `Sum_{k=0..n}`)
+- Non-strict mode is permissive but doesn't validate against ASCII Math spec
+
 ## New API
 
 ### ASCII Math Parser (general use)
 
+**Option A: Dedicated ASCII Math parser**
+
 ```typescript
 // New method on ComputeEngine
 ce.parseAsciiMath('sqrt(x^2 + 1)')  // → BoxedExpression
@@ -56,6 +101,19 @@ ce.parseAsciiMath('sqrt(x^2 + 1)')  // → BoxedExpression
 expr.toAsciiMath() → string → ce.parseAsciiMath() → same expr
 ```
 
+**Option B: Use LaTeX parser in non-strict mode** _(recommended for simplicity)_
+
+```typescript
+// Use existing LaTeX parser with strict: false
+ce.parse('sqrt(x^2 + 1)', { strict: false })  // → BoxedExpression
+
+// Advantages:
+// - Reuses existing parser infrastructure
+// - No need for new parser implementation
+// - Handles most OEIS notation already
+// - Maintains single source of truth for parsing logic
+```
+
 ### MathJSON Functions for Sequence Analysis
 
 These functions take sequence terms and evaluate to formulas by looking up OEIS:
@@ -112,6 +170,8 @@ interface ParsedOEISFormula {
 
 ## Files to Modify
 
+**If using dedicated ASCII Math parser (Option A):**
+
 | File                                                       | Change                                                                               |
 | ---------------------------------------------------------- | ------------------------------------------------------------------------------------ |
 | `src/compute-engine/boxed-expression/ascii-math-parser.ts` | **NEW** - ASCII Math parser                                                          |
@@ -123,11 +183,23 @@ interface ParsedOEISFormula {
 | `test/compute-engine/ascii-math-parser.test.ts`            | **NEW** - Parser tests + round-trip                                                  |
 | `test/compute-engine/oeis.test.ts`                         | Add formula parsing tests                                                            |
 
+**If using LaTeX parser with strict: false (Option B - recommended):**
+
+| File                                            | Change                                                                               |
+| ----------------------------------------------- | ------------------------------------------------------------------------------------ |
+| ~~`ascii-math-parser.ts`~~                      | **NOT NEEDED** - Use LaTeX parser with `strict: false`                               |
+| `src/compute-engine/latex-syntax/types.ts`      | ✅ **DONE** - Added `strict?: boolean` to `ParseLatexOptions`                        |
+| `src/compute-engine/oeis.ts`                    | Add OEIS pre-processing (`a(n)` → `a_n`), `declareOEISSequence()`                   |
+| `src/compute-engine/library/sequences.ts`       | **NEW** or extend - Add ClosedForm, Recurrence, GeneratingFunction, OEISId functions |
+| `src/compute-engine/index.ts`                   | Expose `declareOEISSequence()`                                                       |
+| `src/compute-engine/global-types.ts`            | Add new type definitions                                                             |
+| `test/compute-engine/oeis.test.ts`              | Add formula parsing tests using `parse(formula, {strict: false})`                    |
+
 ## Implementation Phases
 
 ### Phase 1: ASCII Math Parser Core
 
-Create `ascii-math-parser.ts`:
+**Option A: Build dedicated ASCII Math parser** Create `ascii-math-parser.ts`:
 
 - Tokenizer for ASCII Math notation
 - Precedence-climbing parser (similar to LaTeX parser but simpler)
@@ -136,12 +208,25 @@ Create `ascii-math-parser.ts`:
 - Handle symbols: `pi`, `phi`, Greek letters, single-letter variables
 - Handle subscripts: `a_n`, `a_(n-1)`
 
+**Option B: Use LaTeX parser with `strict: false`** _(✅ IMPLEMENTED)_
+
+- **Already handles**: `sqrt(x)`, `sin(x)`, `x^(n+1)`, `a_(k+m)`, `(n+1)/b`
+- **Still needed**: OEIS-specific pre-processing for `a(n)` → `a_n` notation
+- **Benefit**: No new parser needed, leverages existing tested infrastructure
+
 ### Phase 2: Round-trip Testing
 
+**If using dedicated parser:**
+
 - Test: `toAsciiMath(parseAsciiMath(str)) ≈ str`
 - Test: `parseAsciiMath(toAsciiMath(expr)).isSame(expr)`
 - Use existing serializer output as test cases
 
+**If using LaTeX parser with strict: false:**
+
+- Test: `parse(str, {strict: false}).toAsciiMath() ≈ str`
+- Verify OEIS notation compatibility with non-strict mode
+
 ### Phase 3: OEIS Pre-processing
 
 Add to `oeis.ts`:

src/api.md

@@ -5368,6 +5368,7 @@ dictionary entries to define custom LaTeX parsing and serialization.
 
 ```ts
 type ParseLatexOptions = NumberFormat & {
+  strict: boolean;
   skipSpace: boolean;
   parseNumbers: "auto" | "rational" | "decimal" | "never";
   getSymbolType: (symbol) => BoxedType;
@@ -5381,6 +5382,20 @@ type ParseLatexOptions = NumberFormat & {
 
 The LaTeX parsing options can be used with the `ce.parse()` method.
 
+#### ParseLatexOptions.strict
+
+```ts
+strict: boolean;
+```
+
+Controls the strictness of LaTeX parsing:
+
+- `true`: Strict LaTeX syntax required (e.g., `\sin{x}`, `x^{n+1}`)
+- `false`: Accept relaxed Math-ASCII/Typst-like syntax in addition to
+  LaTeX (e.g., `sin(x)`, `x^(n+1)`)
+
+**Default**: `true`
+
 #### ParseLatexOptions.skipSpace
 
 ```ts

src/compute-engine/index.ts

@@ -2178,6 +2178,7 @@ export class ComputeEngine implements IComputeEngine {
 
       repeatingDecimal: 'auto', // auto will accept any notation
 
+      strict: true,
       skipSpace: true,
       parseNumbers: 'auto',
       getSymbolType: (id) => {

src/compute-engine/latex-syntax/dictionary/definitions-core.ts

@@ -623,7 +623,10 @@ export const DEFINITIONS_CORE: LatexDictionary = [
       // return null (or interpret as a symbol).
 
       // Parse either a group or a single symbol
-      const rhs = parser.parseGroup() ?? parser.parseToken();
+      let rhs = parser.parseGroup() ?? parser.parseToken();
+      // In non-strict mode, also accept parenthesized expressions
+      if (rhs === null && parser.options.strict === false && parser.peek === '(')
+        rhs = parser.parseEnclosure();
       return ['Subscript', lhs, rhs];
     },
   } as PostfixEntry,

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

@@ -1757,6 +1757,112 @@ export class _Parser implements Parser {
     return null;
   }
 
+  /**
+   * In non-strict mode, try to parse a bare function name followed by parentheses.
+   * This allows syntax like `sin(x)` instead of requiring `\sin(x)`.
+   *
+   * Returns the parsed function call or null if not a bare function.
+   */
+  private tryParseBareFunction(until?: Readonly<Terminator>): Expression | null {
+    if (this.options.strict !== false) return null;
+
+    const start = this.index;
+
+    // Collect consecutive letter tokens to form a potential function name
+    let name = '';
+    while (!this.atEnd && /^[a-zA-Z]$/.test(this.peek)) {
+      name += this.peek;
+      this.index++;
+    }
+
+    if (!name) {
+      this.index = start;
+      return null;
+    }
+
+    this.skipSpace();
+
+    // Check if followed by opening parenthesis
+    if (this.peek !== '(') {
+      this.index = start;
+      return null;
+    }
+
+    // Map of common function names to their LaTeX equivalents
+    const BARE_FUNCTION_MAP: Record<string, string> = {
+      // Trigonometric
+      sin: 'Sin',
+      cos: 'Cos',
+      tan: 'Tan',
+      cot: 'Cot',
+      sec: 'Sec',
+      csc: 'Csc',
+      // Hyperbolic
+      sinh: 'Sinh',
+      cosh: 'Cosh',
+      tanh: 'Tanh',
+      coth: 'Coth',
+      sech: 'Sech',
+      csch: 'Csch',
+      // Inverse trigonometric
+      arcsin: 'Arcsin',
+      arccos: 'Arccos',
+      arctan: 'Arctan',
+      arccot: 'Arccot',
+      arcsec: 'Arcsec',
+      arccsc: 'Arccsc',
+      asin: 'Arcsin',
+      acos: 'Arccos',
+      atan: 'Arctan',
+      // Inverse hyperbolic
+      arcsinh: 'Arsinh',
+      arccosh: 'Arcosh',
+      arctanh: 'Artanh',
+      arccoth: 'Arcoth',
+      arcsech: 'Arsech',
+      arccsch: 'Arcsch',
+      asinh: 'Arsinh',
+      acosh: 'Arcosh',
+      atanh: 'Artanh',
+      // Logarithms and exponentials
+      log: 'Log',
+      ln: 'Ln',
+      exp: 'Exp',
+      lg: 'Lg',
+      lb: 'Lb',
+      // Other common functions
+      sqrt: 'Sqrt',
+      abs: 'Abs',
+      sgn: 'Sgn',
+      sign: 'Sgn',
+      floor: 'Floor',
+      ceil: 'Ceil',
+      round: 'Round',
+      max: 'Max',
+      min: 'Min',
+      gcd: 'Gcd',
+      lcm: 'Lcm',
+    };
+
+    const fnName = BARE_FUNCTION_MAP[name];
+    if (!fnName) {
+      // Not a recognized function name, backtrack
+      this.index = start;
+      return null;
+    }
+
+    // Parse the arguments in the enclosure (parentheses)
+    const args = this.parseArguments('enclosure', until);
+
+    if (args === null) {
+      // No valid arguments found, backtrack
+      this.index = start;
+      return null;
+    }
+
+    return [fnName, ...args];
+  }
+
   /**
    * Parse a sequence superfix/subfix operator, e.g. `^{*}`
    *
@@ -1787,8 +1893,16 @@ export class _Parser implements Parser {
         if (this.match('_') || this.match('^'))
           subscripts.push(this.error('syntax-error', subIndex));
         else {
-          const sub =
-            this.parseGroup() ?? this.parseToken() ?? this.parseStringGroup();
+          let sub = this.parseGroup() ?? this.parseToken();
+          // In non-strict mode, also accept parenthesized expressions
+          // Note: After match('_'), peek has changed but TypeScript doesn't know
+          if (
+            sub === null &&
+            this.options.strict === false &&
+            (this.peek as string) === '('
+          )
+            sub = this.parseEnclosure();
+          sub ??= this.parseStringGroup();
           if (sub === null) return this.error('missing', index);
 
           subscripts.push(sub);
@@ -1798,7 +1912,15 @@ export class _Parser implements Parser {
         if (this.match('_') || this.match('^'))
           superscripts.push(this.error('syntax-error', subIndex));
         else {
-          const sup = this.parseGroup() ?? this.parseToken();
+          let sup = this.parseGroup() ?? this.parseToken();
+          // In non-strict mode, also accept parenthesized expressions
+          // Note: After match('^'), peek has changed but TypeScript doesn't know
+          if (
+            sup === null &&
+            this.options.strict === false &&
+            (this.peek as string) === '('
+          )
+            sup = this.parseEnclosure();
           if (sup === null) return this.error('missing', index);
           superscripts.push(sup);
         }
@@ -2104,6 +2226,9 @@ export class _Parser implements Parser {
     if (result === null && this.matchAll(this._imaginaryUnitTokens))
       result = 'ImaginaryUnit';
 
+    // In non-strict mode, try to parse bare function names like sin(x)
+    result ??= this.tryParseBareFunction(until);
+
     // ParseGenericExpression() has priority. Some generic expressions
     // may include symbols which have not been explicitly defined
     // with a 'symbol' kind

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

@@ -705,6 +705,17 @@ export type NumberSerializationFormat = NumberFormat & {
  */
 
 export type ParseLatexOptions = NumberFormat & {
+  /**
+   * Controls the strictness of LaTeX parsing:
+   *
+   * - `true`: Strict LaTeX syntax required (e.g., `\sin{x}`, `x^{n+1}`)
+   * - `false`: Accept relaxed Math-ASCII/Typst-like syntax in addition to
+   *   LaTeX (e.g., `sin(x)`, `x^(n+1)`)
+   *
+   * **Default**: `true`
+   */
+  strict: boolean;
+
   /**
    * If true, ignore space characters in math mode.
    *