Function getSequenceStatus

src/compute-engine/sequence.ts:702–767

(
  ce: ComputeEngine,
  name: string
)

  if (symbols.length === 1) return symbols[0];

  // Multiple symbols or no symbols - ambiguous
  // Try to find common index variable names
  const commonVars = ['n', 'k', 'i', 'j', 'm'];
  for (const v of commonVars) {
    if (symbols.includes(v)) return v;
  }

  return undefined;
}

/**
 * Get the status of a sequence definition.
 *
 * Returns information about whether a sequence is complete, pending, or not defined.
 * Supports both single-index and multi-index sequences.
 */
export function getSequenceStatus(
  ce: ComputeEngine,
  name: string
): SequenceStatus {
  // Check for pending sequence first
  const pendingMap = pendingSequences.get(ce);
  const pending = pendingMap?.get(name);

  if (pending) {
    // Sort base indices appropriately
    const baseIndices = Array.from(pending.base.keys());
    if (!pending.isMultiIndex) {
      // Single-index: sort numerically
      (baseIndices as number[]).sort((a, b) => a - b);
    }
    // Multi-index: keep as strings, sort lexicographically

    return {
      status: 'pending',
      hasBase: pending.base.size > 0,
      hasRecurrence: !!pending.recurrence,
      baseIndices,
      variable: pending.recurrence?.variable,
      variables: pending.recurrence?.variables,
    };
  }

  // Check if symbol has subscriptEvaluate (complete sequence)
  const def = ce.lookupDefinition(name);
  if (def && isValueDef(def) && def.value.subscriptEvaluate) {
    // It's a complete sequence - get details from registry
    const registry = sequenceRegistry.get(ce);
    const metadata = registry?.get(name);

    if (metadata) {
      const baseIndices = Array.from(metadata.base.keys());
      if (!metadata.isMultiIndex) {
        // Single-index: sort numerically
        (baseIndices as number[]).sort((a, b) => a - b);
      }

      return {