Function reduceBigOp

src/compute-engine/library/utils.ts:561–645

(
  body: Expression,
  indexes: ReadonlyArray<Expression>,
  fn: (acc: T, x: Expression) => T | null,
  initial: T
)

 */
export function symbolicProductClosedForm(
  body: Expression | undefined,
  limits: Expression,
  ce: ComputeEngine
): Expression | undefined {
  if (!body || !isFunction(limits, 'Limits')) return undefined;
  const index = isSymbol(limits.op1) ? limits.op1.symbol : undefined;
  const lower = limits.op2;
  const upper = limits.op3;
  if (!index || !lower || !upper) return undefined;

  // Π_{k=1}^{n} k = n!  (bare index, lower bound 1).
  if (isSymbol(body) && body.symbol === index && lower.isSame(1))
    return ce.function('Factorial', [upper]);

  // Telescoping product: body = h(k+1)/h(k).
  const { num, den } = asSingleFraction(body, ce);
  if (new Set(num.unknowns).has(index) && new Set(den.unknowns).has(index)) {
    // forward: den shifted by k→k+1 equals num ⇒ body = h(k+1)/h(k), h = den.
    if (shiftIndex(den, index, ce).isSame(num))
      return ce.function('Divide', [
        num.subs({ [index]: upper }),
        den.subs({ [index]: lower }),
      ]);
    // mirror: num shifted by k→k+1 equals den ⇒ body = h(k)/h(k+1), h = num.
    if (shiftIndex(num, index, ce).isSame(den))
      return ce.function('Divide', [
        num.subs({ [index]: lower }),
        den.subs({ [index]: upper }),
      ]);
  }

  return undefined;
}

/**
 * Reformat an evaluated closed form so a rational multiple of a symbolic factor
 * reads as a fraction: `Multiply(Rational(p, q), R)` → `Divide(p·R, q)` (and
 * `Divide(R, q)` when `p = 1`). Mirrors the readability intent of the
 * telescoping `Subtract` above (`π²/6` instead of `(1/6)·π²`). Any other shape
 * is returned unchanged.
 */
function asReadableFraction(z: Expression, ce: ComputeEngine): Expression {
  if (!isFunction(z, 'Multiply')) return z;
  let coeff: Expression | undefined;
  const rest: Expression[] = [];
  for (const op of z.ops) {
    if (coeff === undefined && isNumber(op) && op.im === 0) coeff = op;
    else rest.push(op);
  }
  if (coeff === undefined || rest.length === 0) return z;
  const [num, den] = coeff.numeratorDenominator;
  if (den.isSame(1)) return z;
  const restExpr =
    rest.length === 1
      ? rest[0]
      : ce.function('Multiply', rest, { form: 'structural' });
  const numExpr = num.isSame(1)
    ? restExpr