data/make_tables.py

"""Generate appendix LaTeX tables (full per-task results) from results.py."""
import os
from decimal import Decimal, ROUND_HALF_UP
from results import RESULTS, TASK_LABEL, TASK_GROUPS, PALOMA_LABEL, PALOMA_ORDER, tally, verdict, paloma_verdict

OUT = os.path.join(os.path.dirname(__file__), "..", "appendix_tables.tex")

TIER_NAME = {"HQ": "high-quality (HQ)", "MQ": "medium-quality (MQ)", "LQ": "low-quality (LQ)"}


def _ndec(x):
    """Number of decimals with which a value is stored (= reported in the result tables)."""
    t = repr(x)
    return len(t.split(".")[1]) if "." in t else 0


def hu(x, nd=2):
    """Half-up rounding (as in the result tables) of a computed statistic, signed."""
    q = Decimal(str(x)).quantize(Decimal(1).scaleb(-nd), rounding=ROUND_HALF_UP)
    return f"{q:+.{nd}f}"


def fmt_z(z):
    """z at the precision the result tables report it (1 decimal, 2 for most MQ values)."""
    if z is None:
        return "--"
    s = f"{z:+.{max(1, _ndec(z))}f}"
    if abs(z) >= 2:
        return r"\textbf{\boldmath " + s + "}"   # \boldmath: the math sign added by mathsign() is bold too
    return s


def fmt_d(d, nd=1):
    return f"{d:+.{nd}f}"


_SIGN = __import__("re").compile(r"(?<=[&\s{])([+-])(?=\d)")


def mathsign(row):
    """Typeset the sign of every signed number in a table row as a math +/- (not a hyphen)."""
    return _SIGN.sub(lambda m: "$" + m.group(1) + "$", row)


def downstream_table(tier):
    ds1, _ = RESULTS[(tier, "V1")]
    ds2, _ = RESULTS[(tier, "V2")]
    d1 = {r[0]: r for r in ds1}
    d2 = {r[0]: r for r in ds2}
    lines = []
    lines.append(r"\begin{table}[ht]")
    lines.append(r"\caption{Full downstream results on the " + TIER_NAME[tier] + r" tier: Raw (mean over three pre-training seeds) vs.\ V1 (surface repair) and V2 (surface + linguistic repair). $\sigma$ is the noise band $\sigma_{\mathrm{tot}}$ of \S\ref{sec:protocol} for that arm (its components $\sigma_{\mathrm{pretrain}}$, $\sigma_{\mathrm{eval}}$ and $\sigma_{\mathrm{binom}}$ are in the supplement's \texttt{data/results.py}); $z=\Delta/\sigma$; bold: $|z|\geq 2$. SQuAD~v2 values are reproduced as recorded by the evaluation script; their scale (above 100) is undecoded and its direction is not interpreted, so they are excluded from the percentage-point means and contribute no verdict.}")
    lines.append(r"\label{tab:full-" + tier.lower() + "}")
    lines.append(r"\begin{center}\small\setlength{\tabcolsep}{2.6pt}")
    lines.append(r"\begin{tabular}{l r rrrr rrrr}")
    lines.append(r"\toprule")
    lines.append(r" & & \multicolumn{4}{c}{V1 (surface)} & \multicolumn{4}{c}{V2 (surface + linguistic)} \\")
    lines.append(r"\cmidrule(lr){3-6}\cmidrule(lr){7-10}")
    lines.append(r"Task & Raw & $\sigma$ & mean & $\Delta$ (pp) & $z$ & $\sigma$ & mean & $\Delta$ (pp) & $z$ \\")
    lines.append(r"\midrule")
    for gname, tasks in TASK_GROUPS:
        lines.append(r"\multicolumn{10}{l}{\textit{" + gname + r"}} \\")
        for t in tasks:
            r1, r2 = d1[t], d2[t]
            raw = r1[1]
            nd = 2 if tier == "MQ" else 1
            lines.append(mathsign(
                f"{TASK_LABEL[t]} & {raw:.{nd}f} & {r1[5]:.3f} & {r1[6]:.{nd}f} & {fmt_d(r1[7], nd)} & {fmt_z(r1[9])} & "
                f"{r2[5]:.3f} & {r2[6]:.{nd}f} & {fmt_d(r2[7], nd)} & {fmt_z(r2[9])} \\\\"))
    t1, t2 = tally(tier, "V1"), tally(tier, "V2")
    lines.append(r"\midrule")
    lines.append(r"\multicolumn{2}{l}{Robust wins / losses ($|z|\geq 2$)} & \multicolumn{4}{c}{" + f"{t1['dW']} / {t1['dL']}" + r"} & \multicolumn{4}{c}{" + f"{t2['dW']} / {t2['dL']}" + r"} \\")
    mean1 = sum(Decimal(str(r[7])) for r in ds1 if r[0] != "squadv2") / 26
    mean2 = sum(Decimal(str(r[7])) for r in ds2 if r[0] != "squadv2") / 26
    lines.append(mathsign(r"\multicolumn{2}{l}{Mean $\Delta$ over 26 accuracy tasks (pp)} & \multicolumn{4}{c}{" + hu(mean1) + r"} & \multicolumn{4}{c}{" + hu(mean2) + r"} \\"))
    lines.append(r"\bottomrule")
    lines.append(r"\end{tabular}")
    lines.append(r"\end{center}")
    lines.append(r"\end{table}")
    return "\n".join(lines)


def paloma_table(tier):
    _, p1 = RESULTS[(tier, "V1")]
    _, p2 = RESULTS[(tier, "V2")]
    d1 = {r[0]: r for r in p1}
    d2 = {r[0]: r for r in p2}
    lines = []
    lines.append(r"\begin{table}[ht]")
    lines.append(r"\caption{Full Paloma bits-per-byte (BPB) results on the " + TIER_NAME[tier] + r" tier (lower is better). $\Delta$ is in BPB, $\Delta_{rel}$ in \%; $z=\Delta/\sigma_{\mathrm{tot}}$ with $\sigma_{\mathrm{tot}}=\sigma_{\mathrm{pretrain}}$ (no binomial fallback for continuous metrics). Bold: $|z|\geq 2$; negative $z$ is an improvement.}")
    lines.append(r"\label{tab:paloma-" + tier.lower() + "}")
    lines.append(r"\begin{center}\small\setlength{\tabcolsep}{4pt}")
    lines.append(r"\begin{tabular}{l r r rrr rrr}")
    lines.append(r"\toprule")
    lines.append(r" & & & \multicolumn{3}{c}{V1 (surface)} & \multicolumn{3}{c}{V2 (surface + linguistic)} \\")
    lines.append(r"\cmidrule(lr){4-6}\cmidrule(lr){7-9}")
    lines.append(r"Paloma corpus & Raw BPB & $\sigma_{\mathrm{tot}}$ & BPB & $\Delta_{rel}$ & $z$ & BPB & $\Delta_{rel}$ & $z$ \\")
    lines.append(r"\midrule")
    for c in PALOMA_ORDER:
        r1, r2 = d1[c], d2[c]
        lines.append(mathsign(
            f"{PALOMA_LABEL[c]} & {r1[1]:.4f} & {r1[4]:.4f} & {r1[5]:.4f} & {r1[7]:+.2f}\\% & {fmt_z(r1[8])} & "
            f"{r2[5]:.4f} & {r2[7]:+.2f}\\% & {fmt_z(r2[8])} \\\\"))
    t1, t2 = tally(tier, "V1"), tally(tier, "V2")
    lines.append(r"\midrule")
    lines.append(r"\multicolumn{3}{l}{Robust wins / losses ($|z|\geq 2$)} & \multicolumn{3}{c}{" + f"{t1['pW']} / {t1['pL']}" + r"} & \multicolumn{3}{c}{" + f"{t2['pW']} / {t2['pL']}" + r"} \\")
    m1 = sum(Decimal(str(r[7])) for r in p1) / len(p1)
    m2 = sum(Decimal(str(r[7])) for r in p2) / len(p2)
    lines.append(mathsign(r"\multicolumn{3}{l}{Mean $\Delta_{rel}$ over 11 corpora} & \multicolumn{3}{c}{" + hu(m1) + r"\%} & \multicolumn{3}{c}{" + hu(m2) + r"\%} \\"))
    lines.append(r"\bottomrule")
    lines.append(r"\end{tabular}")
    lines.append(r"\end{center}")
    lines.append(r"\end{table}")
    return "\n".join(lines)


STRICT = 2 * (1 + 1 / 3) ** 0.5  # single-run repaired config: SE = sqrt(1+1/n) sigma_tot, n=3 seeds


def _counts(tier, cfg, thr, floor=False):
    ds, pal = RESULTS[(tier, cfg)]
    # SQuAD v2 never reaches |z| >= 2 in either direction, so it contributes no verdict.
    def zf(r):
        if floor and r[4] is not None and r[7] is not None and r[4] > 0 and r[5] is not None and r[4] > r[5]:
            return r[7] / r[4]          # sigma_tot floored at sigma_binom (multiple-choice tasks)
        return r[9]
    dW = sum(1 for r in ds if verdict(zf(r), thr) == "W")
    dL = sum(1 for r in ds if verdict(zf(r), thr) == "L")
    pW = sum(1 for r in pal if paloma_verdict(r[8], thr) == "W")
    pL = sum(1 for r in pal if paloma_verdict(r[8], thr) == "L")
    return dW, dL, pW, pL, dW + pW - dL - pL


def _zrep(z):
    """Print z at the precision it is reported in the result tables (1 or 2 decimals)."""
    return f"{z:+.{max(1, _ndec(z))}f}"


def _between(tier, cfg, lo=2.0, hi=STRICT):
    ds, pal = RESULTS[(tier, cfg)]
    out = []
    for r in ds:
        if r[0] != "squadv2" and r[9] is not None and lo <= abs(r[9]) < hi:
            out.append(f"{TASK_LABEL[r[0]]} ({'W' if r[9] > 0 else 'L'}, ${_zrep(r[9])}$)")
    for r in pal:
        if r[8] is not None and lo <= abs(r[8]) < hi:
            out.append(f"{PALOMA_LABEL[r[0]]} ({'W' if r[8] < 0 else 'L'}, ${_zrep(r[8])}$)")
    return ", ".join(out) if out else "none"


BONF = 3.2125 * (4 / 3) ** 0.5   # two-sided Bonferroni over 38 evaluations (3.2125), scaled like the single-run correction: 3.71
LADDER = [("2", 2.0), ("2.31", STRICT), ("3.71", BONF), ("5", 5.0)]


def strict_table():
    def net(n):
        return f"${n:+d}$" if n != 0 else "$0$"
    between = []
    for tier in ("HQ", "MQ", "LQ"):
        b = _between(tier, "V2")
        if b != "none":
            between.append(f"{tier}-V2: {b}")
    between_txt = "; ".join(between)
    lines = []
    lines.append(r"\begin{table}[ht]")
    lines.append(r"\caption{Sensitivity of the verdict tallies to the counting rule (\S\ref{sec:protocol}). Thresholds: $|z|\geq2$ (the protocol), $2\sqrt{1+1/3}\approx2.31$ (two standard errors when one treatment run is compared with a three-seed mean of equal variance), $3.71$ (two-sided Bonferroni over the 38 evaluations, 3.21, scaled by the same $\sqrt{4/3}$) and $5$ (above the two-degree-of-freedom $t$ cutoff 4.30 scaled the same way, 4.97); these are descriptive sensitivity cutoffs, not calibrated tests. Floor: $|z|\geq2$ with $\sigma_{\mathrm{tot}}$ floored at $\sigma_{\mathrm{binom}}$ for every multiple-choice task, which removes the near-degenerate denominators (e.g.\ SocialIQA on MQ-V1). DS: the 27 downstream tasks (SQuAD~v2 never reaches $|z|\geq2$); Pal.: the 11 Paloma corpora; W/L = wins/losses. V2 is net-positive and V1 is never net-positive on every tier under every rule. Verdicts with $2\leq|z|<2.31$ (all V2; no V1 or Paloma verdict lies there): " + between_txt + r".}")
    lines.append(r"\label{tab:strict}")
    lines.append(r"\begin{center}\footnotesize\setlength{\tabcolsep}{2.2pt}")
    lines.append(r"\begin{tabular}{@{}ll " + " ".join(["ccr"] * (len(LADDER) + 1)) + r"@{}}")
    lines.append(r"\toprule")
    head = " & ".join([r"\multicolumn{3}{c}{$|z|\geq " + lab + "$}" for lab, _ in LADDER]) + r" & \multicolumn{3}{c}{Floor}"
    lines.append(r" & & " + head + r" \\")
    cm = "".join([f"\\cmidrule(lr){{{3+3*i}-{5+3*i}}}" for i in range(len(LADDER) + 1)])
    lines.append(cm)
    lines.append(r"Tier & Repair & " + " & ".join([r"DS & Pal.\ & net"] * (len(LADDER) + 1)) + r" \\")
    lines.append(r"\midrule")
    for tier in ("HQ", "MQ", "LQ"):
        for cfg in ("V1", "V2"):
            cells = []
            for _, thr in LADDER:
                a = _counts(tier, cfg, thr)
                cells.append(f"{a[0]}/{a[1]} & {a[2]}/{a[3]} & {net(a[4])}")
            a = _counts(tier, cfg, 2.0, floor=True)
            cells.append(f"{a[0]}/{a[1]} & {a[2]}/{a[3]} & {net(a[4])}")
            lines.append(f"{tier if cfg == 'V1' else ''} & {cfg} & " + " & ".join(cells) + r" \\")
        if tier != "LQ":
            lines.append(r"\midrule")
    lines.append(r"\bottomrule")
    lines.append(r"\end{tabular}")
    lines.append(r"\end{center}")
    lines.append(r"\end{table}")
    return "\n".join(lines)


# --------------------------------------------------------------------------
# Anatomy of the effect (main-text Table 3) and signal classification (App. G)
# --------------------------------------------------------------------------
# Random-choice baseline 1/k for multiple-choice tasks; None = open-ended or no simple baseline.
RANDOM_K = {"lambada_openai": None, "blimp": 2, "sciq": 4, "arc_easy": 4, "arc_challenge": 4, "pubmedqa": 3,
            "mmlu": 4, "hellaswag": 4, "piqa": 2, "commonsense_qa": 5, "social_iqa": 3, "copa": 2,
            "openbookqa": 4, "winogrande": 2, "logiqa": 4, "anli_r1": 3, "anli_r2": 3, "anli_r3": 3, "rte": 2,
            "cb": 3, "boolq": 2, "truthfulqa_mc2": None, "race": 4, "coqa": None, "triviaqa": None, "nq_open": None}
OPEN_SIGNAL = {"lambada_openai", "coqa"}   # open-ended tasks scored well above zero on every tier


def _tasks26():
    return [k for _, ts in TASK_GROUPS for k in ts if k != "squadv2"]


def signal_split():
    """Signal task: Raw score >= 10 pp above random choice (1/k) on every tier; open-ended LAMBADA and CoQA
    are included, TriviaQA/NQ-Open (<6% exact match) and TruthfulQA-MC2 (no simple random baseline) are not."""
    sig, near = [], []
    for k in _tasks26():
        raws = [{r[0]: r for r in RESULTS[(t, "V2")][0]}[k][1] for t in ("HQ", "MQ", "LQ")]
        if RANDOM_K[k] is None:
            (sig if k in OPEN_SIGNAL else near).append(k)
        else:
            (sig if min(r - 100.0 / RANDOM_K[k] for r in raws) >= 10 else near).append(k)
    return sig, near


def _anatomy(tier, cfg):
    d = {r[0]: r for r in RESULTS[(tier, cfg)][0]}
    p = {r[0]: r for r in RESULTS[(tier, cfg)][1]}
    ks = _tasks26()
    sig, _ = signal_split()
    tb = sum(1 for k in ks if d[k][7] > 0); tw = sum(1 for k in ks if d[k][7] < 0)
    pb = sum(1 for k in p if p[k][7] < 0); pw = sum(1 for k in p if p[k][7] > 0)
    gain = sum(d[k][7] for k in ks if d[k][7] > 0); loss = -sum(d[k][7] for k in ks if d[k][7] < 0)
    sb = sum(1 for k in sig if d[k][7] > 0); sw = sum(1 for k in sig if d[k][7] < 0)
    sW = sum(1 for k in sig if d[k][9] >= 2); sL = sum(1 for k in sig if d[k][9] <= -2)
    pg = -sum(p[k][7] for k in p if p[k][7] < 0); pl = sum(p[k][7] for k in p if p[k][7] > 0)
    v1lower = None
    if cfg == "V2":
        p1 = {r[0]: r for r in RESULTS[(tier, "V1")][1]}
        v1lower = sum(1 for k in p if p[k][5] < p1[k][5])
    return dict(better=tb + pb, worse=tw + pw, gain=gain, loss=loss, sb=sb, sw=sw, sW=sW, sL=sL, pg=pg, pl=pl, v1lower=v1lower)


def anatomy_table():
    sig, _ = signal_split()
    L = []
    L.append(r"\begin{table}[t]")
    L.append(r"\caption{Anatomy of the effect against Raw, counting every evaluation regardless of significance (ties omitted). Signal tasks: the " + str(len(sig)) + r" tasks whose Raw score is at least 10\pp{} above random choice on every tier (Table~\ref{tab:signal}); W/L: robust wins/losses. Gain/loss: summed positive and negative changes.}")
    L.append(r"\label{tab:anatomy}")
    L.append(r"\centering\footnotesize\setlength{\tabcolsep}{5pt}")
    L.append(r"\begin{tabular}{@{}ll c c cc c@{}}")
    L.append(r"\toprule")
    L.append(r" & & 37 evaluations & 26 tasks (pp) & \multicolumn{2}{c}{" + str(len(sig)) + r" signal tasks} & 11 Paloma (\% BPB) \\")
    L.append(r"\cmidrule(lr){3-3}\cmidrule(lr){4-4}\cmidrule(lr){5-6}\cmidrule(lr){7-7}")
    L.append(r"Tier & Repair & better / worse & gain / loss & better / worse & W / L & gain / loss \\")
    L.append(r"\midrule")
    for tier in ("HQ", "MQ", "LQ"):
        for cfg in ("V1", "V2"):
            a = _anatomy(tier, cfg)
            lab = "V1 surface" if cfg == "V1" else "V2 + linguistic"
            b = f"{a['better']}"
            if cfg == "V2":
                b = r"\textbf{" + b + "}"
            L.append(f"{tier if cfg == 'V1' else ''} & {lab} & {b} / {a['worse']} & {a['gain']:.1f} / {a['loss']:.1f} & "
                     f"{a['sb']} / {a['sw']} & {a['sW']} / {a['sL']} & {a['pg']:.1f} / {a['pl']:.1f} \\\\")
        if tier != "LQ":
            L.append(r"\midrule")
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    L.append(r"\end{table}")
    return "\n".join(L)


def signal_table():
    sig, near = signal_split()
    L = []
    L.append(r"\begin{table}[ht]")
    L.append(r"\caption{Classification of the 26 downstream tasks used in Table~\ref{tab:anatomy}. Random choice is $1/k$ for $k$ answer options; the Raw range is over the three tiers. A task has \emph{signal} at this scale if its Raw score is at least 10\pp{} above random choice on every tier; LAMBADA and CoQA are open-ended and far above zero; TriviaQA and NQ-Open are below 6\% exact match, and TruthfulQA-MC2 has no simple random baseline.}")
    L.append(r"\label{tab:signal}")
    L.append(r"\begin{center}\footnotesize\setlength{\tabcolsep}{4pt}")
    L.append(r"\begin{tabular}{@{}lccl@{}}")
    L.append(r"\toprule")
    L.append(r"Task & random choice (\%) & Raw range (\%) & class \\")
    L.append(r"\midrule")
    for k in _tasks26():
        raws = [{r[0]: r for r in RESULTS[(t, "V2")][0]}[k][1] for t in ("HQ", "MQ", "LQ")]
        rc = "--" if RANDOM_K[k] is None else f"{100.0 / RANDOM_K[k]:.1f}"
        cls = "signal" if k in sig else ("floor" if k in ("triviaqa", "nq_open") else "near chance")
        if k == "truthfulqa_mc2":
            cls = "no baseline"
        L.append(f"{TASK_LABEL[k]} & {rc} & {min(raws):.1f}--{max(raws):.1f} & {cls} \\\\")
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    L.append(r"\end{center}")
    L.append(r"\end{table}")
    return "\n".join(L)


# --------------------------------------------------------------------------
# In-depth analysis tables (main-text Table 2; App. analysis tables)
# --------------------------------------------------------------------------
FORMAT_GROUPS = [
    ("Passage-conditioned", ["lambada_openai", "sciq", "pubmedqa", "boolq", "race", "coqa", "logiqa"]),
    ("Premise--hypothesis", ["anli_r1", "anli_r2", "anli_r3", "rte", "cb"]),
    ("Short context", ["blimp", "hellaswag", "piqa", "commonsense_qa", "social_iqa", "copa", "winogrande"]),
    ("Closed-book knowledge", ["mmlu", "arc_easy", "arc_challenge", "openbookqa", "truthfulqa_mc2", "triviaqa", "nq_open"]),
]


def _grp(tier, cfg, ks):
    d = {r[0]: r for r in RESULTS[(tier, cfg)][0]}
    return dict(mean=sum(d[k][7] for k in ks) / len(ks), b=sum(1 for k in ks if d[k][7] > 0),
                w=sum(1 for k in ks if d[k][7] < 0), W=sum(1 for k in ks if d[k][9] >= 2),
                L=sum(1 for k in ks if d[k][9] <= -2))


def _robust(tier, cfg):
    ds, pal = RESULTS[(tier, cfg)]
    W = sum(1 for r in ds if r[9] >= 2) + sum(1 for r in pal if r[8] <= -2)
    L = sum(1 for r in ds if r[9] <= -2) + sum(1 for r in pal if r[8] >= 2)
    return W, L


def main_summary_table():
    L = []
    L.append(r"\captionof{table}{The full repair pipeline (V2) against Raw. Robust W/L: evaluations with $|z|\geq2$ in favour of / against repair (38 per tier); better/worse: all 37 scored evaluations regardless of significance (ties omitted); gain/loss: summed positive and negative changes; passage-conditioned tasks: the 7 tasks whose items include a multi-sentence passage (\S\ref{sec:analysis}). Surface-only repair (V1) and per-family Paloma means are in App.~\ref{app:full}.}")
    L.append(r"\label{tab:summary}")
    L.append(r"\centering\footnotesize\setlength{\tabcolsep}{4.2pt}")
    L.append(r"\begin{tabular}{@{}l cc c c c c@{}}")
    L.append(r"\toprule")
    L.append(r" & \multicolumn{2}{c}{Robust ($|z|\geq2$)} & All evaluations & 26 tasks (pp) & 11 Paloma (\%) & 7 passage tasks \\")
    L.append(r"\cmidrule(lr){2-3}\cmidrule(lr){4-4}\cmidrule(lr){5-5}\cmidrule(lr){6-6}\cmidrule(lr){7-7}")
    L.append(r"Tier & W / L & net & better / worse & gain / loss & gain / loss & better / worse, W / L \\")
    L.append(r"\midrule")
    tot = dict(W=0, L=0, b=0, w=0, g=0.0, l=0.0, pg=0.0, pl=0.0, gb=0, gw=0, gW=0, gL=0)
    for tier in ("HQ", "MQ", "LQ"):
        W, Lr = _robust(tier, "V2")
        a = _anatomy(tier, "V2")
        g = _grp(tier, "V2", FORMAT_GROUPS[0][1])
        L.append(f"{tier} & {W} / {Lr} & $+{W - Lr}$ & {a['better']} / {a['worse']} & {a['gain']:.1f} / {a['loss']:.1f} & "
                 f"{a['pg']:.1f} / {a['pl']:.1f} & {g['b']} / {g['w']}, {g['W']} / {g['L']} \\\\")
        tot['W'] += W; tot['L'] += Lr; tot['b'] += a['better']; tot['w'] += a['worse']
        tot['g'] += a['gain']; tot['l'] += a['loss']; tot['pg'] += a['pg']; tot['pl'] += a['pl']
        tot['gb'] += g['b']; tot['gw'] += g['w']; tot['gW'] += g['W']; tot['gL'] += g['L']
    L.append(r"\midrule")
    L.append(f"All & \\textbf{{{tot['W']} / {tot['L']}}} & $+{tot['W'] - tot['L']}$ & \\textbf{{{tot['b']} / {tot['w']}}} & {tot['g']:.1f} / {tot['l']:.1f} & "
             f"{tot['pg']:.1f} / {tot['pl']:.1f} & {tot['gb']} / {tot['gw']}, {tot['gW']} / {tot['gL']} \\\\")
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    return "\n".join(L)


def format_group_table():
    L = []
    L.append(r"\begin{table}[ht]")
    L.append(r"\caption{Downstream changes of the full pipeline (V2) by task input format. Mean $\Delta$ in pp; better/worse over the tasks of the group; W/L: robust wins/losses. Groups are defined by a dataset property (whether an item contains a multi-sentence passage, a premise--hypothesis pair, a short context, or a closed-book question), not by the results; the MQ premise--hypothesis mean is carried by CB ($+23.8$\pp, not robust). Pooled: over the three tiers.}")
    L.append(r"\label{tab:formats}")
    L.append(r"\begin{center}\footnotesize\setlength{\tabcolsep}{4pt}")
    L.append(r"\begin{tabular}{@{}l c ccc ccc ccc c@{}}")
    L.append(r"\toprule")
    L.append(r" & & \multicolumn{3}{c}{HQ} & \multicolumn{3}{c}{MQ} & \multicolumn{3}{c}{LQ} & Pooled \\")
    L.append(r"\cmidrule(lr){3-5}\cmidrule(lr){6-8}\cmidrule(lr){9-11}\cmidrule(lr){12-12}")
    L.append(r"Group & $n$ & mean & b/w & W/L & mean & b/w & W/L & mean & b/w & W/L & better (of $3n$) \\")
    L.append(r"\midrule")
    for name, ks in FORMAT_GROUPS:
        cells = []
        pooled = 0
        for tier in ("HQ", "MQ", "LQ"):
            g = _grp(tier, "V2", ks)
            cells.append(f"${g['mean']:+.2f}$ & {g['b']}/{g['w']} & {g['W']}/{g['L']}")
            pooled += g['b']
        L.append(f"{name} & {len(ks)} & " + " & ".join(cells) + f" & {pooled} of {3 * len(ks)} \\\\")
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    L.append(r"\end{center}")
    L.append(r"\end{table}")
    return "\n".join(L)


def paloma_replication_table():
    from results import PALOMA_FAMILY
    L = []
    L.append(r"\begin{table}[ht]")
    L.append(r"\caption{Replication of the full pipeline's effect on each Paloma corpus across the three disjoint tiers (relative BPB change, \%; negative is better). Range: largest minus smallest of the three tier values.}")
    L.append(r"\label{tab:replication}")
    L.append(r"\begin{center}\footnotesize\setlength{\tabcolsep}{5pt}")
    L.append(r"\begin{tabular}{@{}llrrrrr@{}}")
    L.append(r"\toprule")
    L.append(r"Corpus & group & HQ & MQ & LQ & mean & range \\")
    L.append(r"\midrule")
    for c in PALOMA_ORDER:
        v = [{r[0]: r for r in RESULTS[(t, "V2")][1]}[c][7] for t in ("HQ", "MQ", "LQ")]
        L.append(mathsign(f"{PALOMA_LABEL[c]} & {PALOMA_FAMILY[c]} & {v[0]:+.2f} & {v[1]:+.2f} & {v[2]:+.2f} & "
                          f"{sum(v) / 3:+.2f} & {max(v) - min(v):.2f} \\\\"))
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    L.append(r"\end{center}")
    L.append(r"\end{table}")
    return "\n".join(L)


def sensitivity_table():
    """Equal-weight task means of the full pipeline under exclusions, plus the two-way decomposition of the Paloma effects."""
    import numpy as np
    T = ("HQ", "MQ", "LQ")
    ds = {t: {r[0]: r for r in RESULTS[(t, "V2")][0]} for t in T}
    tasks = [k for k in ds["HQ"] if k != "squadv2"]
    rows = []
    for excl, name in (([], "All 26 tasks"), (["cb"], "Without CB"), (["cb", "lambada_openai"], "Without CB and LAMBADA")):
        ks = [k for k in tasks if k not in excl]
        per = [float(np.mean([ds[t][k][7] for k in ks])) for t in T]
        rows.append((name, per, float(np.mean(per))))
    M = np.array([[{r[0]: r for r in RESULTS[(t, "V2")][1]}[c][7] for c in PALOMA_ORDER] for t in T])
    g = M.mean(); tm = M.mean(axis=1, keepdims=True); cm = M.mean(axis=0, keepdims=True)
    sst = ((M - g) ** 2).sum(); ss_t = ((tm - g) ** 2).sum() * M.shape[1]; ss_c = ((cm - g) ** 2).sum() * M.shape[0]
    ss_r = ((M - tm - cm + g) ** 2).sum()
    L = []
    L.append(r"\begin{table}[ht]")
    L.append(r"\caption{Sensitivity of the full pipeline's downstream mean to the two most conspicuous gains (equal-weight mean change in pp over the tasks listed; SQuAD~v2 excluded throughout), and a two-way decomposition of the 33 Paloma effects (relative BPB changes) into between-corpus, between-tier and residual variation. Both are descriptive summaries of the recorded results.}")
    L.append(r"\label{tab:sensitivity}")
    L.append(r"\begin{center}\footnotesize\setlength{\tabcolsep}{6pt}")
    L.append(r"\begin{tabular}{@{}lrrrr@{}}")
    L.append(r"\toprule")
    L.append(r"Tasks included & HQ & MQ & LQ & pooled \\")
    L.append(r"\midrule")
    for name, per, pooled in rows:
        L.append(f"{name} & " + " & ".join(f"${v:+.2f}$" for v in per) + f" & ${pooled:+.2f}$ \\\\")
    L.append(r"\midrule")
    L.append(r"\multicolumn{5}{@{}l}{Paloma effects: variation between evaluation corpora " + f"{100 * ss_c / sst:.1f}" + r"\%, between input tiers " + f"{100 * ss_t / sst:.1f}" + r"\%, residual " + f"{100 * ss_r / sst:.1f}" + r"\%} \\")
    def _dec(Mx):
        gx = Mx.mean(); tmx = Mx.mean(axis=1, keepdims=True); cmx = Mx.mean(axis=0, keepdims=True)
        return 100 * ((cmx - gx) ** 2).sum() * Mx.shape[0] / ((Mx - gx) ** 2).sum()
    lab = {c: PALOMA_LABEL[c] for c in PALOMA_ORDER}
    pal = {t: {r[0]: r for r in RESULTS[(t, "V2")][1]} for t in T}
    c4 = [c for c in PALOMA_ORDER if lab[c] in ("C4-en", "C4-100-domains")]
    rest = [c for c in PALOMA_ORDER if c not in c4]
    M2 = np.array([[pal[t][c][7] for c in rest] + [np.mean([pal[t][c][7] for c in c4])] for t in T])
    drop = [c for c in PALOMA_ORDER if lab[c] in ("Falcon-RefinedWeb", "C4-en", "C4-100-domains")]
    M3 = np.array([[pal[t][c][7] for c in PALOMA_ORDER if c not in drop] for t in T])
    L.append(r"\multicolumn{5}{@{}l}{\quad between corpora, C4 evaluations merged: " + f"{_dec(M2):.1f}" + r"\%} \\")
    L.append(r"\multicolumn{5}{@{}l}{\quad between corpora, without Falcon-RefinedWeb and both C4: " + f"{_dec(M3):.1f}" + r"\%} \\")
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    L.append(r"\end{center}")
    L.append(r"\end{table}")
    return "\n".join(L)


def threshold_table():
    """Counts of full-pipeline task changes whose magnitude reaches a threshold, with and without CB and LAMBADA."""
    T = ("HQ", "MQ", "LQ")
    ds = {t: {r[0]: r for r in RESULTS[(t, "V2")][0]} for t in T}
    tasks = [k for k in ds["HQ"] if k != "squadv2"]
    L = []
    L.append(r"\begin{table}[ht]")
    L.append(r"\caption{Full-pipeline downstream changes against Raw whose magnitude reaches a threshold (improvements / declines over task--tier pairs; smaller changes omitted). Descriptive counts of the recorded changes, not significance tests.}")
    L.append(r"\label{tab:thresholds}")
    L.append(r"\begin{center}\footnotesize\setlength{\tabcolsep}{8pt}")
    L.append(r"\begin{tabular}{@{}lcc@{}}")
    L.append(r"\toprule")
    L.append(r"Threshold & All 26 tasks (78 pairs) & Without CB and LAMBADA (72 pairs) \\")
    L.append(r"\midrule")
    for th in (0.5, 1, 2):
        cells = []
        for excl in ([], ["cb", "lambada_openai"]):
            ks = [k for k in tasks if k not in excl]
            g = sum(1 for t in T for k in ks if ds[t][k][7] >= th)
            l = sum(1 for t in T for k in ks if ds[t][k][7] <= -th)
            cells.append(f"{g} / {l}")
        lab = f"$\\geq{th:g}$\\pp"
        L.append(f"{lab} & {cells[0]} & {cells[1]} \\\\")
    L.append(r"\bottomrule")
    L.append(r"\end{tabular}")
    L.append(r"\end{center}")
    L.append(r"\end{table}")
    return "\n".join(L)


if __name__ == "__main__":
    parts = ["% Auto-generated by data/make_tables.py -- do not edit by hand."]
    parts.append(strict_table())
    for tier in ("HQ", "MQ", "LQ"):
        parts.append(downstream_table(tier))
        parts.append(paloma_table(tier))
        parts.append(r"\clearpage")
    parts.append(signal_table())
    open(OUT, "w").write("\n\n".join(parts) + "\n")
    print("wrote", OUT)
    open(os.path.join(os.path.dirname(OUT), "table_anatomy.tex"), "w").write(
        "% Auto-generated by data/make_tables.py -- do not edit by hand.\n" + anatomy_table() + "\n")
    open(os.path.join(os.path.dirname(OUT), "table_summary.tex"), "w").write(
        "% Auto-generated by data/make_tables.py -- do not edit by hand.\n" + main_summary_table() + "\n")
    open(os.path.join(os.path.dirname(OUT), "appendix_analysis_tables.tex"), "w").write(
        "% Auto-generated by data/make_tables.py -- do not edit by hand.\n" + format_group_table() + "\n\n" + paloma_replication_table() + "\n\n" + sensitivity_table() + "\n\n" + threshold_table() + "\n")
    print("wrote table_anatomy.tex, table_summary.tex, appendix_analysis_tables.tex")
    # print the summary numbers used in the main text (half-up, as in the result tables)
    from results import PALOMA_FAMILY
    D = lambda v: Decimal(str(v))
    for tier in ("HQ", "MQ", "LQ"):
        for cfg in ("V1", "V2"):
            ds, pal = RESULTS[(tier, cfg)]
            m = sum(D(r[7]) for r in ds if r[0] != "squadv2") / 26
            pm = sum(D(r[7]) for r in pal) / 11
            fam = {}
            for r in pal:
                fam.setdefault(PALOMA_FAMILY[r[0]], []).append(D(r[7]))
            print(tier, cfg, "meanDS", hu(m), "| Paloma all", hu(pm),
                  " ".join(f"| {k} {hu(sum(v) / len(v))}" for k, v in fam.items()))