fix: #273

Author: arnog

CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ### New Features
 
+- **Type-Aware Subscript Handling**: Subscripts on symbols declared as collection
+  types (list, tuple, matrix, etc.) now automatically convert to `At()` indexing
+  operations:
+
+  ```javascript
+  ce.declare('v', 'list<number>');
+  ce.parse('v_n');      // → At(v, n)
+  ce.parse('v_{n+1}');  // → At(v, n+1)
+  ce.parse('v_{i,j}');  // → At(v, Tuple(i, j))
+  ```
+
+  This works for both simple subscripts (`v_n`) and complex subscripts (`v_{n+1}`).
+  The type of the `At()` expression is correctly inferred from the collection's
+  element type, allowing subscripted collection elements to be used in arithmetic.
+
+- **Complex Subscripts in Arithmetic** (Issue #273): Subscript expressions like
+  `a_{n+1}` can now be used in arithmetic operations without type errors:
+
+  ```javascript
+  ce.parse('a_{n+1} + 1');     // → Add(Subscript(a, n+1), 1)
+  ce.parse('2 * a_{n+1}');     // → Multiply(2, Subscript(a, n+1))
+  ce.parse('a_{n+1}^2');       // → Power(Subscript(a, n+1), 2)
+  ```
+
+  Previously, complex subscripts would fail with "incompatible-type" errors
+  when used in arithmetic contexts.
+
 - **Special Functions**: Added type signatures for special mathematical functions,
   enabling them to be used in expressions without type errors:
   - `Zeta` - Riemann zeta function ζ(s)

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

@@ -283,14 +283,22 @@ export function parseSymbol(parser: Parser): MathJsonSymbol | null {
   if (/^[a-zA-Z]$/.test(parser.peek) || /^\p{XIDS}$/u.test(parser.peek)) {
     let id = parser.nextToken();
 
+    // Check if the symbol is declared as a collection type.
+    // If so, don't absorb subscripts into the symbol name - let them be
+    // handled as Subscript expressions which will convert to At() calls.
+    const symbolType = parser.getSymbolType(id);
+    const isCollection = symbolType.matches('indexed_collection');
+
     // Check if followed by subscript(s) - if so, include them in the symbol name
     // This ensures 'i_A' is parsed as a single symbol 'i_A', not as a subscript
     // applied to 'i' (which would turn 'i' into ImaginaryUnit first)
     // However, complex subscripts should remain as Subscript expressions:
     // - {n,m} (comma indicates multi-index)
     // - {n+1} (operators indicate an expression)
     // - {(n+1)} (parentheses indicate an expression)
-    while (!parser.atEnd) {
+    // Also, if the symbol is a collection type, all subscripts should be
+    // Subscript expressions (which convert to At() calls).
+    while (!parser.atEnd && !isCollection) {
       const currentPeek = parser.peek;
       if (currentPeek !== '_') break;
 

src/compute-engine/library/collections.ts

@@ -810,7 +810,10 @@ export const COLLECTIONS_LIBRARY: SymbolDefinitions = {
     ],
     complexity: 8200,
     signature: '(value: list|tuple|string, index: number | string) -> unknown',
-    type: ([xs]) => xs.operatorDefinition?.collection?.elttype?.(xs) ?? 'any',
+    type: ([xs]) =>
+      xs.operatorDefinition?.collection?.elttype?.(xs) ??
+      collectionElementType(xs.type.type) ??
+      'any',
 
     evaluate: (ops, { engine: ce }) => {
       // @todo: the implementation does not match the description. Need to think this through...

src/compute-engine/library/core.ts

@@ -731,7 +731,33 @@ export const CORE_LIBRARY: SymbolDefinitions[] = [
         if (op1.string && asSmallInteger(op2) !== null) return 'integer';
         if (op1.isIndexedCollection)
           return collectionElementType(op1.type.type) ?? 'any';
-        if (op1.symbol) return 'symbol';
+
+        // Check if the symbol is declared as a collection type
+        if (op1.symbol) {
+          const eltType = collectionElementType(op1.type.type);
+          if (eltType) return eltType;
+        }
+
+        // For symbol bases with complex subscripts (like a_{n+1}), return 'unknown'
+        // to allow type inference in arithmetic contexts. Simple subscripts
+        // (like a_n) are converted to compound symbols during canonicalization
+        // and won't reach this type function.
+        if (op1.symbol) {
+          // Check if this would become a compound symbol (simple subscript)
+          const sub =
+            op2.string ?? op2.symbol ?? asSmallInteger(op2)?.toString();
+          if (sub) return 'symbol';
+          // Check for InvisibleOperator of symbols/numbers (also becomes compound symbol)
+          if (op2.operator === 'InvisibleOperator' && op2.ops) {
+            const parts = op2.ops.map(
+              (x) => x.symbol ?? asSmallInteger(x)?.toString()
+            );
+            if (parts.every((p) => p !== undefined && p !== null))
+              return 'symbol';
+          }
+          // Complex subscript - return 'unknown' to allow numeric inference
+          return 'unknown';
+        }
         return 'expression';
       },
 
@@ -754,9 +780,21 @@ export const CORE_LIBRARY: SymbolDefinitions[] = [
           ]);
         }
 
-        // Is it a collection?
+        // Is it a collection expression (like a list literal)?
         if (op1.isIndexedCollection) return ce._fn('At', [op1, op2.canonical]);
 
+        // Is it a symbol declared as a collection type?
+        // If so, convert to At() for indexing
+        if (op1.symbol && collectionElementType(op1.type.type)) {
+          // For multi-index subscripts (Sequence/Tuple), pass each index as separate arg
+          if (
+            (op2.operator === 'Sequence' || op2.operator === 'Tuple') &&
+            op2.ops
+          )
+            return ce._fn('At', [op1, ...op2.ops.map((x) => x.canonical)]);
+          return ce._fn('At', [op1, op2.canonical]);
+        }
+
         // Is it a compound symbol `x_\operatorname{max}`, `\mu_0`
         if (op1.symbol) {
           const sub =