Function runProblem

scripts/rubi/benchmark.ts:196–441

(
  p: Problem,
  seed: number,
  rubi?: { ce: ComputeEngine; driver: RubiDriver }
)

  if (Math.hypot(Fp.re - Fm.re, Fp.im - Fm.im) < 1e-9 * fMag) return null;
  const d1 = { re: (Fp.re - Fm.re) / (2 * h), im: (Fp.im - Fm.im) / (2 * h) };
  const Fp2 = at(h / 2);
  const Fm2 = at(-h / 2);
  if (!Fp2 || !Fm2) return d1;
  const d2 = { re: (Fp2.re - Fm2.re) / h, im: (Fp2.im - Fm2.im) / h };
  return { re: (4 * d2.re - d1.re) / 3, im: (4 * d2.im - d1.im) / 3 };
}

function runProblem(
  p: Problem,
  seed: number,
  rubi?: { ce: ComputeEngine; driver: RubiDriver }
): ProblemResult {
  const start = Date.now();
  const done = (
    outcome: Outcome,
    extra: Partial<ProblemResult> = {}
  ): ProblemResult => ({
    file: p.file,
    index: p.index,
    source: p.source,
    outcome,
    ms: Date.now() - start,
    ...extra,
  });

  // Fresh engine per problem (avoids cross-problem state) — except in
  // --rubi mode, where compiled patterns are tied to a shared engine.
  const ce = rubi?.ce ?? new ComputeEngine();

  try {
    const f = ce.expr(p.integrand as any);
    const result = rubi
      ? (rubi.driver.int(f, p.variable) ??
        ce.function('Integrate', [f, ce.symbol(p.variable)]))
      : ce.expr(['Integrate', p.integrand as any, p.variable]).evaluate();

    if (containsOperator(result, 'Integrate'))
      return done('unsolved', { result: result.toString() });

    // verification on huge results can grind for minutes — call it
    // inconclusive rather than stalling the harness (numeric
    // central-difference is per-point subs+N, so the budget is generous)
    if (leafCount(result) > 10_000)
      return done('inconclusive', {
        result: result.toString().slice(0, 400),
        detail: 'result too large to verify',
      });

    // Verify: F′(x) ≈ f(x) at sample points via numeric central
    // difference — deliberately NOT symbolic D: the engine's
    // D→simplify pipeline has an unsound x/√(x²) → 1 rewrite (loses
    // sign(x)) that poisons derivative-based checks. (See RUBI.md.)
    const params = new Set<string>();
    collectSymbols(p.integrand, params);
    params.delete(p.variable);

    const rand = mulberry32(seed ^ hash(`${p.file}#${p.index}`));
    let passes = 0;