Function createSequenceHandler

src/compute-engine/sequence.ts:272–428

(
  ce: ComputeEngine,
  name: string,
  def: SequenceDefinition
)

 *
 * The handler evaluates expressions like `F_{10}` or `P_{5,2}` by:
 * 1. Checking base cases first (with pattern matching for multi-index)
 * 2. Looking up memoized values
 * 3. Recursively evaluating the recurrence relation
 *
 * Supports both single-index and multi-index sequences:
 * - Single-index: `F_{10}` with subscript as a number
 * - Multi-index: `P_{5,2}` with subscript as `Sequence(5, 2)`
 */
export function createSequenceHandler(
  ce: ComputeEngine,
  name: string,
  def: SequenceDefinition
): (
  subscript: Expression,
  options: { engine: ComputeEngine; numericApproximation?: boolean }
) => Expression | undefined {
  // Determine if this is a multi-index sequence
  const isMultiIndex = def.variables !== undefined && def.variables.length > 1;
  const variables = def.variables ?? [def.variable ?? 'n'];
  const variable = variables[0]; // For single-index backward compatibility

  const memoize = def.memoize ?? true;
  // Use string keys for multi-index, number keys for single-index
  const memo = memoize ? new Map<number | string, Expression>() : null;
  const domain = def.domain ?? {};

  // Store recurrence source for lazy parsing
  const recurrenceSource = def.recurrence;
  let recurrence: Expression | null = null;

  // Parse and box constraint expression
  let constraintsExpr: Expression | null = null;
  if (def.constraints) {
    constraintsExpr =
      typeof def.constraints === 'string'
        ? ce.parse(def.constraints)!
        : def.constraints;
  }

  // Box base cases
  const base = new Map<number | string, Expression>();
  for (const [k, v] of Object.entries(def.base)) {
    const key = isMultiIndex ? String(k) : Number(k);
    base.set(key, typeof v === 'number' ? ce.number(v) : v);
  }

  // For multi-index: prepare sorted base cases for pattern matching
  const preparedBaseCases = isMultiIndex ? prepareBaseCases(base) : null;

  // Register sequence for introspection (SUB-7)
  registerSequence(ce, {
    name,
    variable: isMultiIndex ? undefined : variable,
    variables: isMultiIndex ? variables : undefined,
    isMultiIndex,
    base,
    memoize,
    memo,