Function canonicalLimitsSequence

src/compute-engine/library/utils.ts:253–306

(
  ops: ReadonlyArray<Expression>,
  options: { engine: ComputeEngine }
)

      // symbol `n`, or `n − 1` — cannot be enumerated: the domain is
      // symbolic. Without this check `normalizeIndexingSet` silently
      // substitutes its default iteration window for the unusable bound, so
      // `Sum(k, [k, 1, n])` evaluated as if `n` were 10001 (→ 50015001).
      const symbolicBound = (b: Expression) =>
        !(isSymbol(b) && b.symbol === 'Nothing') &&
        Number.isNaN(bigopBoundValue(b));
      if (symbolicBound(idx.op2) || symbolicBound(idx.op3)) return 'symbolic';
      if (!normalizeIndexingSet(idx).isFinite) infinite = true;
    }
  }

  if (!infinite) return 'finite';

  // The body is numeric iff its only free variables are the index variables.
  // (`unknowns` already excludes constants like `Pi` and any name bound to a
  // value, and function heads are not counted as free variables.)
  const numericBody = (body?.unknowns ?? []).every((s) => indexNames.has(s));
  return numericBody ? 'numeric' : 'symbolic';
}

/**
 * Shift a body's index `k → k + 1`, returning the substituted expression.
 */
function shiftIndex(
  expr: Expression,
  index: string,
  ce: ComputeEngine
): Expression {
  return expr.subs({ [index]: ce.box(['Add', index, 1]) });
}

/**
 * Decompose a telescoping body `Add(a, b)` (exactly two terms, exactly one a
 * `Negate`) into its positive and negative parts and the orientation:
 *   - forward: body = t(k+1) − t(k)  (with `t = neg`), sums to t(b+1) − t(a)
 *   - mirror:  body = t(k) − t(k+1)  (with `t = pos`), sums to t(a) − t(b+1)
 * Both parts must depend on the index. Returns undefined if the body is not a
 * `k → k+1` shift pair.
 */
function telescopingParts(
  body: Expression,
  index: string,
  ce: ComputeEngine
): { pos: Expression; neg: Expression; forward: boolean } | undefined {
  if (!isFunction(body, 'Add') || body.ops.length !== 2) return undefined;

  let pos: Expression | undefined;
  let neg: Expression | undefined;
  for (const t of body.ops) {
    if (isFunction(t, 'Negate')) {
      if (neg) return undefined; // two negated terms → not a telescoping pair
      neg = t.op1;
    } else {
      if (pos) return undefined;
      pos = t;
    }
  }
  if (!pos || !neg) return undefined;