Function reduceElementIndexingSets

src/compute-engine/library/utils.ts:665–793

* Handle Element-based indexing sets by extracting finite domains * and iterating over their values. * * Returns a detailed result to distinguish between: * - Success: domain was enumerated and reduced * - Non-enumerable: domain is valid but cannot be enumerated (keep expression symbolic) * -

(
  body: Expression,
  indexes: ReadonlyArray<Expression>,
  fn: (acc: T, x: Expression) => T | null,
  initial: T,
  returnReason = false
  // Yields only accumulator values (`T | undefined`) between iterations; the
  // detailed `ReduceElementResult` classification is delivered as the *return*
  // value. Splitting yield/return types lets `reduceBigOp` re-yield each
  // accumulator (for deadline checks) without widening its own yield type.
)

    return undefined;
  if (!isFunction(body, 'Power')) return undefined;
  const base = body.op1;
  const exp = body.op2;
  if (!(isSymbol(base) && base.symbol === index)) return undefined;
  if (!isNumber(exp) || exp.im !== 0) return undefined;
  const r = exp.re;
  // s = −exp must be a real > 1 for absolute convergence (s = 1 is the
  // harmonic/ζ(1) pole; s ≤ 1 diverges).
  if (!(Number.isFinite(r) && r < -1)) return undefined;
  const s = exp.neg();
  const z = ce.function('Zeta', [s]).evaluate();
  if (lowerValue === 1) return asReadableFraction(z, ce);

  const terms: Expression[] = [z];
  for (let k = 1; k < lowerValue; k++)
    terms.push(
      body
        .subs({ [index]: k })
        .evaluate()
        .neg()
    );
  return asReadableFraction(ce.function('Add', terms).evaluate(), ce);
}

/**
 * Closed form of a geometric series `Σ_{k=n₀}^∞ c·rᵏ = c·r^{n₀}/(1 − r)`, valid
 * for `|r| < 1` (conditional-values design, Phase 3a). `r` must be free of the
 * index `k`; `n₀` is an integer-literal lower bound; an index-free constant
 * factor `c` is allowed (`c·rᵏ`).
 *
 * The convergence condition `|r| < 1` is routed through the `conditionalValue`
 * chokepoint:
 *   - numeric `r` with `|r| < 1`  → the bare exact value (per the exactness
 *     contract: `Σ(1/2)ᵏ → 2`, not `2.`);
 *   - numeric `r` with `|r| ≥ 1`  → `undefined` (decidable-divergent: caller
 *     keeps the sum symbolic, mirroring the p-series entry);
 *   - symbolic `r`                → `When(c·r^{n₀}/(1 − r), |r| < 1)`.
 *
 * Scope is deliberately just this family: no x-dependent ratios (`Σ n·xⁿ`),
 * symbolic start indices, or derivative-of-geometric shapes.
 */
function geometricSumClosedForm(
  body: Expression,
  index: string,
  lower: Expression,
  ce: ComputeEngine
): Expression | undefined {
  if (!lower.isInteger) return undefined;
  const n0 = lower.re;
  if (!Number.isSafeInteger(n0)) return undefined;

  // Separate an optional index-free constant factor `c` from the `rᵏ` power.
  let coeff: Expression = ce.One;
  let power: Expression = body;
  if (isFunction(body, 'Multiply')) {
    const consts: Expression[] = [];
    const varying: Expression[] = [];
    for (const f of body.ops) (f.has(index) ? varying : consts).push(f);
    if (varying.length !== 1) return undefined;