Function classify

benchmarks/report.mjs:135–198

(kase, res)

// verdict.v ∈ correct | partial | wrong | unsupported | unevaluated | timeout | error
function classify(kase, res) {
  if (!res) return { v: 'unsupported' };
  if (res.status === 'timeout') return { v: 'timeout' };
  if (res.status === 'unsupported') return { v: 'unsupported', note: res.reason };
  if (res.status === 'error') return { v: 'error', note: res.error };
  if (res.status === 'unevaluated') return { v: 'unevaluated' };
  if (res.status === 'overflow') return { v: 'wrong', note: 'overflow' };

  const vr = kase.verify;
  if (vr.kind === 'decimal') {
    const m = matchingSigDigits(res.valueText, vr.value);
    // -3 absorbs display rounding (a value can print a few fewer digits than
    // requested when a carry collapses a run of trailing 9s, e.g. e).
    if (m >= vr.sigdigits - 3) return { v: 'correct', note: `${Math.min(m, vr.sigdigits)} digits` };
    if (m >= 14) return { v: 'partial', note: `~${m} digits (double)` };
    return { v: 'wrong', note: `${m} digits` };
  }
  if (vr.kind === 'integer') {
    const got = normalizeInt(res.valueText);
    return got === vr.value ? { v: 'correct', note: 'exact' } : { v: 'wrong', note: 'inexact' };
  }
  if (vr.kind === 'sample') {
    if (!allClose(res.values, vr.values)) return { v: 'wrong', note: 'value mismatch' };
    if (kase.category === 'simplify') {
      // A decimal-float result is a numeric evaluation, not a symbolic
      // simplification (e.g. √(3+2√2) -> 2.414… instead of 1+√2). Exact
      // results like `0`, `1`, `4x` are fine — only flag a many-digit decimal.
      if (/^[+-]?\d+\.\d{4,}(e[+-]?\d+)?$/i.test(norm(res.text)))
        return { v: 'partial', note: 'numeric, not symbolic' };
      const changed = norm(res.text) !== norm(res.inputText);
      return changed ? { v: 'correct' } : { v: 'partial', note: 'value ok, not simplified' };
    }
    return { v: 'correct' };
  }
  if (vr.kind === 'diff') {
    return allClose(res.values, [vr.value]) ? { v: 'correct' } : { v: 'wrong', note: 'value mismatch' };
  }
  if (vr.kind === 'value') {
    // Evaluate-to-closed-form: numerically correct AND symbolic (not a bare
    // float). A many-digit decimal is a numeric fallback, not an exact result.
    if (!allClose(res.values, [vr.value], 1e-9)) return { v: 'wrong', note: 'value mismatch' };
    if (/^[+-]?\d+\.\d{4,}(e[+-]?\d+)?$/i.test(norm(res.text)))
      return { v: 'partial', note: 'numeric, not exact' };
    return { v: 'correct' };
  }
  if (vr.kind === 'roots') {
    // Bijectively match the tool's returned real roots against the reference
    // real-root set (order-independent), within a relative tolerance.
    const got = (res.values || []).map(Number).filter(Number.isFinite);
    const exp = vr.values.map(parseFloat);
    const tol = 1e-6;
    const used = new Array(got.length).fill(false);
    let matched = 0;
    for (const e of exp) {
      const j = got.findIndex((g, k) => !used[k] && Math.abs(g - e) <= tol * (1 + Math.abs(e)));
      if (j >= 0) { used[j] = true; matched++; }
    }
    const spurious = used.filter((u) => !u).length;