code/analyze.py

"""P0-2: do the PRE-MERGE predictors predict the REALISED rescue?
Held out by seed pair (SET 1) and by language pair (SET 4). Held-out AUROC + permutation null
(seed-cluster permutation, which respects the pair dependence structure) + BH correction."""
import os, sys, json, glob, itertools
sys.path.insert(0, "/root/compose-audit")
from common import *
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

R = "/root/compose-audit/results"
F = "/root/compose-audit/figs"
os.makedirs(F, exist_ok=True)


def load(pat):
    rows = []
    for fp in sorted(glob.glob(f"{R}/{pat}")):
        for line in open(fp):
            try: rows.append(json.loads(line))
            except Exception: pass
    return rows


# ------------------------------------------------------------------ stats helpers
def auroc(score, label):
    s, y = np.asarray(score, float), np.asarray(label, int)
    ok = np.isfinite(s)
    s, y = s[ok], y[ok]
    if y.sum() == 0 or y.sum() == len(y):
        return float("nan")
    order = np.argsort(s)
    ranks = np.empty(len(s), float); ranks[order] = np.arange(1, len(s) + 1)
    # average ranks for ties
    for v in np.unique(s):
        m = s == v
        if m.sum() > 1:
            ranks[m] = ranks[m].mean()
    n1, n0 = y.sum(), len(y) - y.sum()
    return float((ranks[y == 1].sum() - n1 * (n1 + 1) / 2) / (n1 * n0))


def spearman(x, y):
    x, y = np.asarray(x, float), np.asarray(y, float)
    ok = np.isfinite(x) & np.isfinite(y)
    if ok.sum() < 3: return float("nan")
    rx = np.argsort(np.argsort(x[ok])).astype(float)
    ry = np.argsort(np.argsort(y[ok])).astype(float)
    return EV.pearson(rx, ry)


def bh(pvals):
    p = np.asarray(pvals, float)
    ok = np.isfinite(p)
    out = np.full(len(p), np.nan)
    idx = np.where(ok)[0]
    o = idx[np.argsort(p[idx])]
    m = len(o)
    prev = 1.0
    for rank in range(m - 1, -1, -1):
        v = min(prev, p[o[rank]] * m / (rank + 1))
        out[o[rank]] = v; prev = v
    return out


def ridge(X, y, lam=1.0):
    Xb = np.hstack([X, np.ones((len(X), 1))])
    A = Xb.T @ Xb + lam * np.eye(Xb.shape[1])
    w = np.linalg.solve(A, Xb.T @ y)
    return w[:-1], w[-1]


# ------------------------------------------------------------------ SET 1 assembly
set1 = load("set1_*.jsonl")
rows1 = []
for r in set1:
    rg = r["rungs"]
    m1 = {k: v for k, v in rg.items() if k.startswith("M1")}
    best = min(m1, key=lambda k: m1[k]["delta_floor"]) if m1 else None
    d0 = rg["M0_naive_avg"]["delta_floor"]
    d1 = m1[best]["delta_floor"] if best else float("nan")
    row = {"set": "SET1_polypythia", "substrate": f"pythia-{r['size']}", "size": r["size"],
           "pair": f"{r['pair'][0]}-{r['pair'][1]}", "a": r["pair"][0], "b": r["pair"][1],
           "floor": r["floor"], "dfloor_M0": d0, "dfloor_M1best": d1, "M1best": best,
           "rescue_nats": d0 - d1, "rescue_frac": (d0 - d1) / d0 if d0 > 0 else float("nan")}
    for k, v in rg.items():
        row[f"nll_{k}"] = v["nll"]; row[f"dfloor_{k}"] = v["delta_floor"]
    for k in ("barrier_naive", "barrier_perm"):
        if k in r: row[k] = r[k]["barrier"]
    row.update({f"p_{k}": v for k, v in r["predictors"].items()})
    row["align_perm_hidden"] = r["align_info"]["perm"].get("hidden", 0)
    row["align_perm_heads"] = r["align_info"]["perm"].get("heads", 0)
    row["align_perm_residual"] = int(bool(r["align_info"]["perm"].get("residual")))
    rows1.append(row)

# ------------------------------------------------------------------ SET 4 assembly
set4 = load("set4_goldfish.jsonl")
rows4 = []
for r in set4:
    rg = r["rungs"]
    # Re-reference the X-language floor to the X parent's OWN tokenizer. The English parent's
    # nats/byte on X text is degenerate wherever the English tokenizer UNK-s the script (46% of
    # Greek tokens), so min(parents) was picking up an artifact rather than a floor.
    px = r["parents"]["x_on_x"]["nats_per_byte"]
    for _k, _v in rg.items():
        _v["delta_floor_x"] = _v["x"]["nats_per_byte"] - px
        _v["delta_floor_mean"] = 0.5 * (_v["delta_floor_eng"] + _v["delta_floor_x"])
    r["floor_x"] = px
    m1 = {k: v for k, v in rg.items() if k.startswith("M1")}
    best = min(m1, key=lambda k: m1[k]["delta_floor_eng"]) if m1 else None
    d0 = rg["M0_naive_avg"]["delta_floor_eng"]
    d1 = m1[best]["delta_floor_eng"] if best else float("nan")
    row = {"set": "SET4_goldfish", "substrate": "goldfish-125M", "pair": f"eng-{r['lang']}",
           "lang": r["lang"], "floor_eng": r["floor_eng"], "floor_x": r["floor_x"],
           "dfloor_M0": d0, "dfloor_M1best": d1, "M1best": best,
           "rescue_nats": d0 - d1, "rescue_frac": (d0 - d1) / d0 if d0 > 0 else float("nan")}
    for k, v in rg.items():
        for f_ in ("delta_floor_eng", "delta_floor_x", "delta_floor_mean"):
            row[f"{f_}_{k}"] = v[f_]
        row[f"npb_eng_{k}"] = v["eng"]["nats_per_byte"]; row[f"npb_x_{k}"] = v["x"]["nats_per_byte"]
    for k in ("barrier_naive", "barrier_perm"):
        if k in r: row[k] = r[k]["barrier"]
    row.update({f"p_{k}": v for k, v in r["predictors"].items()})
    rows4.append(row)


def to_csv(rows, path):
    if not rows: return
    keys = []
    for r in rows:
        for k in r:
            if k not in keys: keys.append(k)
    with open(path, "w") as f:
        f.write(",".join(keys) + "\n")
        for r in rows:
            f.write(",".join("" if r.get(k) is None else str(r.get(k, "")) for k in keys) + "\n")


to_csv(rows1, f"{R}/set1_pairs.csv")
to_csv(rows4, f"{R}/set4_pairs.csv")
print(f"SET1 rows={len(rows1)}  SET4 rows={len(rows4)}")

# ------------------------------------------------------------------ P0-2: held-out prediction, SET 1
PRED_KEYS = ["p_weight_cosine", "p_weight_cosine_bn", "p_d_raw", "p_qmd_perm", "p_coord_share_perm",
             "p_qmd_orth", "p_coord_share_orth", "p_bnd_raw", "p_bnd_perm", "p_bnd_orth",
             "p_coord_share_bnd_perm", "p_coord_share_bnd_orth", "p_cka_mean", "p_cka_last",
             "p_qmd_act_perm", "p_qmd_act_procrustes", "p_qmd_act_ot", "p_task_vector_cosine"]

pred_rows, roc_store = [], {}
OUTCOMES = [("rescue_frac", "fraction of the naive Δfloor that the best M1 rung removes", +1),
            ("dfloor_M1best", "Δfloor of the best M1 rung (how good the ALIGNED merge actually is)", -1)]
for size in sorted({r["size"] for r in rows1}):
    sub = [r for r in rows1 if r["size"] == size]
    if len(sub) < 8:
        continue
    seeds = sorted({r["a"] for r in sub} | {r["b"] for r in sub})
    pair_ix = {(r["a"], r["b"]): i for i, r in enumerate(sub)}
    complete = len(sub) == len(seeds) * (len(seeds) - 1) // 2
    for oname, odesc, osign in OUTCOMES:
        y_cont = osign * np.array([r[oname] for r in sub], float)
        med = np.nanmedian(y_cont)
        y = (y_cont > med).astype(int)
        rng = np.random.default_rng(0)
        # pre-draw the seed-cluster permutations ONCE per outcome so every predictor sees the same null
        perms = []
        for _ in range(2000):
            pi = rng.permutation(seeds)
            m = {sd: pi[i] for i, sd in enumerate(seeds)}
            idx, ok = [], True
            for r in sub:
                u, v = sorted((m[r["a"]], m[r["b"]]))
                if (u, v) not in pair_ix:
                    ok = False; break
                idx.append(pair_ix[(u, v)])
            if ok:
                perms.append(np.asarray(idx))
        for pk in PRED_KEYS:
            x = np.array([r.get(pk, np.nan) for r in sub], float)
            if np.isfinite(x).sum() < 8 or np.nanstd(x) == 0:
                continue
            # HELD OUT BY SEED: fold k = every pair touching seed k, fitted on pairs touching neither,
            # so the predictor's SIGN never sees the held-out pairs.
            oof = np.full(len(sub), np.nan)
            for sd_ in seeds:
                te = np.array([(r["a"] == sd_ or r["b"] == sd_) for r in sub]); tr = ~te
                if tr.sum() < 4 or te.sum() < 1: continue
                sgn = np.sign(spearman(x[tr], y_cont[tr])) or 1.0
                oof[te] = sgn * x[te]
            a_oof = auroc(oof, y)
            a_in = auroc(np.sign(spearman(x, y_cont) or 1.0) * x, y)
            null = np.array([auroc(oof, y[ix]) for ix in perms]) if len(perms) >= 200 else np.array([])
            null = null[np.isfinite(null)]
            pval = float((np.sum(null >= a_oof) + 1) / (len(null) + 1)) if len(null) else float("nan")
            pred_rows.append({"set": "SET1", "substrate": f"pythia-{size}", "outcome": oname,
                              "n_pairs": len(sub), "predictor": pk[2:],
                              "spearman_rescue": spearman(x, y_cont),
                              "auroc_in_sample": a_in, "auroc_heldout_by_seed": a_oof,
                              "perm_null_mean": float(null.mean()) if len(null) else float("nan"),
                              "n_null_draws": int(len(null)), "pairs_complete": int(complete),
                              "perm_null_p": pval})
            if oname == "rescue_frac":
                roc_store[(size, pk)] = (oof, y)
        # multivariate, held out by seed
        X = np.array([[r.get(k, np.nan) for k in PRED_KEYS] for r in sub], float)
        good = np.isfinite(X).all(0) & (np.nanstd(X, 0) > 0)
        Xg = X[:, good]
        Xg = (Xg - Xg.mean(0)) / (Xg.std(0) + 1e-12)
        oof = np.full(len(sub), np.nan)
        for sd_ in seeds:
            te = np.array([(r["a"] == sd_ or r["b"] == sd_) for r in sub]); tr = ~te
            if tr.sum() < 4: continue
            w, b = ridge(Xg[tr], y_cont[tr], lam=2.0)
            oof[te] = Xg[te] @ w + b
        a_oof = auroc(oof, y)
        null = np.array([auroc(oof, y[ix]) for ix in perms]) if len(perms) >= 200 else np.array([])
        null = null[np.isfinite(null)]
        pred_rows.append({"set": "SET1", "substrate": f"pythia-{size}", "outcome": oname,
                          "n_pairs": len(sub), "predictor": "MULTIVARIATE_ridge_all",
                          "spearman_rescue": spearman(oof, y_cont), "auroc_in_sample": float("nan"),
                          "auroc_heldout_by_seed": a_oof,
                          "perm_null_mean": float(null.mean()) if len(null) else float("nan"),
                          "n_null_draws": int(len(null)), "pairs_complete": int(complete),
                          "perm_null_p": float((np.sum(null >= a_oof) + 1) / (len(null) + 1)) if len(null) else float("nan")})

if pred_rows:
    q = bh([r["perm_null_p"] for r in pred_rows])
    for r, qq in zip(pred_rows, q):
        r["bh_q"] = float(qq) if np.isfinite(qq) else ""
    to_csv(pred_rows, f"{R}/predictor_auroc.csv")

# ---------------- P0-2b: does the predictor transfer ACROSS substrates (leave-one-size-out)?
xfer = []
szs_all = sorted({r["size"] for r in rows1 if len([q for q in rows1 if q["size"] == r["size"]]) >= 8})
if len(szs_all) >= 3:
    pool = [r for r in rows1 if r["size"] in szs_all]
    for oname, osign in (("rescue_frac", +1), ("dfloor_M1best", -1)):
        Y = osign * np.array([r[oname] for r in pool], float)
        SZ = np.array([r["size"] for r in pool])
        X = np.array([[r.get(k, np.nan) for k in PRED_KEYS] for r in pool], float)
        good = np.isfinite(X).all(0) & (np.nanstd(X, 0) > 0)
        Xg = X[:, good].copy()
        # standardise WITHIN size: the raw scales differ across substrates, and a predictor that only
        # works because it encodes "which size is this" is not a transferring predictor.
        for sz in szs_all:
            m = SZ == sz
            Xg[m] = (Xg[m] - Xg[m].mean(0)) / (Xg[m].std(0) + 1e-12)
        oof = np.full(len(pool), np.nan)
        for sz in szs_all:
            te = SZ == sz; tr = ~te
            w, b = ridge(Xg[tr], Y[tr], lam=2.0)
            oof[te] = Xg[te] @ w + b
        rng = np.random.default_rng(1)
        for sz in szs_all:
            te = SZ == sz
            y = (Y[te] > np.median(Y[te])).astype(int)
            a = auroc(oof[te], y)
            null = np.array([auroc(oof[te], y[rng.permutation(len(y))]) for _ in range(2000)])
            null = null[np.isfinite(null)]
            xfer.append({"outcome": oname, "held_out_substrate": f"pythia-{sz}", "n": int(te.sum()),
                         "auroc_transfer": a, "null_mean": float(null.mean()),
                         "perm_p": float((np.sum(null >= a) + 1) / (len(null) + 1))})
        # univariate transfer of the single most-cited predictor family
        for pk in ("p_coord_share_bnd_perm", "p_qmd_act_perm", "p_cka_mean", "p_weight_cosine"):
            if pk not in PRED_KEYS: continue
            j = PRED_KEYS.index(pk)
            if not good[j]: continue
            col = np.where(good)[0].tolist().index(j)
            for sz in szs_all:
                te = SZ == sz; tr = ~te
                sgn = np.sign(spearman(Xg[tr, col], Y[tr])) or 1.0
                y = (Y[te] > np.median(Y[te])).astype(int)
                a = auroc(sgn * Xg[te, col], y)
                null = np.array([auroc(sgn * Xg[te, col], y[rng.permutation(len(y))]) for _ in range(1000)])
                null = null[np.isfinite(null)]
                xfer.append({"outcome": oname, "held_out_substrate": f"pythia-{sz}", "n": int(te.sum()),
                             "predictor": pk[2:], "auroc_transfer": a,
                             "null_mean": float(null.mean()),
                             "perm_p": float((np.sum(null >= a) + 1) / (len(null) + 1))})
    for r in xfer:
        r.setdefault("predictor", "MULTIVARIATE_ridge_all")
    qq = bh([r["perm_p"] for r in xfer])
    for r, q in zip(xfer, qq):
        r["bh_q"] = float(q)
    to_csv(xfer, f"{R}/predictor_transfer_across_size.csv")

# SET 4: leave-one-language-out, n=4 -> report Spearman only, flagged as underpowered
pred4 = []
if len(rows4) >= 3:
    y4 = np.array([r["rescue_frac"] for r in rows4], float)
    for pk in PRED_KEYS + ["p_vocab_overlap", "p_weight_cosine_body"]:
        x = np.array([r.get(pk, np.nan) for r in rows4], float)
        if np.isfinite(x).sum() < 3 or np.nanstd(x) == 0: continue
        pred4.append({"set": "SET4", "substrate": "goldfish-125M", "n_pairs": len(rows4),
                      "predictor": pk[2:], "spearman_rescue": spearman(x, y4),
                      "note": "n=4 language pairs -- UNDERPOWERED, no AUROC/null reported"})
    to_csv(pred4, f"{R}/set4_predictors.csv")

# ------------------------------------------------------------------ figures
plt.rcParams.update({"figure.dpi": 130, "font.size": 9, "axes.grid": True,
                     "grid.alpha": .25, "axes.spines.top": False, "axes.spines.right": False})

# 1. Delta-floor by rung
if rows1:
    sizes = sorted({r["size"] for r in rows1}, key=lambda s: int(s[:-1]))
    rungs = [k[7:] for k in rows1[0] if k.startswith("dfloor_M")]
    fig, axes = plt.subplots(1, len(sizes), figsize=(3.6 * len(sizes), 3.4), squeeze=False)
    for ax, sz in zip(axes[0], sizes):
        sub = [r for r in rows1 if r["size"] == sz]
        data = [[r[f"dfloor_{k}"] for r in sub if np.isfinite(r.get(f"dfloor_{k}", np.nan))] for k in rungs]
        keep = [(k, d) for k, d in zip(rungs, data) if d]
        ax.boxplot([d for _, d in keep], tick_labels=[k.replace("_", "\n", 1) for k, _ in keep],
                   showfliers=False)
        ax.set_yscale("symlog"); ax.set_title(f"pythia-{sz}  (n={len(sub)} seed pairs)")
        ax.set_ylabel("Δfloor  (nats/token, log)")
        ax.tick_params(axis="x", labelsize=6)
    fig.suptitle("SET 1 · PolyPythia seed merge · Δfloor vs the better parent, by merge rung", fontsize=10)
    fig.tight_layout(); fig.savefig(f"{F}/set1_dfloor_by_rung.png", bbox_inches="tight"); plt.close(fig)

# 2. rescue vs coordinate share
if rows1:
    fig, axes = plt.subplots(1, 2, figsize=(8.4, 3.6))
    for ax, pk, lab in ((axes[0], "p_coord_share_bnd_perm", "coordinate share (block-normalised, permutation)"),
                        (axes[1], "p_cka_mean", "unaligned CKA (mean over layers)")):
        for sz in sorted({r["size"] for r in rows1}, key=lambda s: int(s[:-1])):
            sub = [r for r in rows1 if r["size"] == sz]
            ax.scatter([r.get(pk, np.nan) for r in sub], [r["rescue_frac"] for r in sub],
                       s=18, alpha=.75, label=f"pythia-{sz}")
        ax.set_xlabel(lab); ax.set_ylabel("realised rescue  (frac of naive Δfloor removed)")
        ax.legend(fontsize=7, frameon=False)
    fig.suptitle("SET 1 · does a PRE-MERGE predictor track the REALISED rescue?", fontsize=10)
    fig.tight_layout(); fig.savefig(f"{F}/set1_rescue_vs_predictor.png", bbox_inches="tight"); plt.close(fig)

# 3. ROC of the best held-out predictor per size
if roc_store and pred_rows:
    fig, ax = plt.subplots(figsize=(4.2, 4))
    best = {}
    for r in pred_rows:
        if r["predictor"].startswith("MULTIVAR"): continue
        sz = r["substrate"].split("-")[1]
        a = r["auroc_heldout_by_seed"]
        if np.isfinite(a) and (sz not in best or abs(a - .5) > abs(best[sz][1] - .5)):
            best[sz] = (r["predictor"], a)
    for sz, (pk, a) in best.items():
        oof, y = roc_store[(sz, "p_" + pk)]
        o = np.argsort(-oof); yy = y[o]
        tpr = np.cumsum(yy) / max(1, yy.sum()); fpr = np.cumsum(1 - yy) / max(1, (1 - yy).sum())
        ax.plot(np.r_[0, fpr], np.r_[0, tpr], label=f"pythia-{sz}: {pk} (AUROC={a:.2f})")
    ax.plot([0, 1], [0, 1], "k--", lw=.8)
    ax.set_xlabel("false positive rate"); ax.set_ylabel("true positive rate")
    ax.set_title("SET 1 · held-out-by-seed ROC\n(best predictor per size)", fontsize=9)
    ax.legend(fontsize=7, frameon=False)
    fig.tight_layout(); fig.savefig(f"{F}/set1_roc.png", bbox_inches="tight"); plt.close(fig)

# 4. SET 4 bars
if rows4:
    rungs = sorted({k[len("delta_floor_mean_"):] for r in rows4 for k in r if k.startswith("delta_floor_mean_M")})
    fig, ax = plt.subplots(figsize=(7.6, 3.6))
    w = 0.8 / len(rungs)
    for i, k in enumerate(rungs):
        ax.bar(np.arange(len(rows4)) + i * w, [r.get(f"delta_floor_mean_{k}", np.nan) for r in rows4],
               width=w, label=k)
    ax.set_xticks(np.arange(len(rows4)) + 0.4 - w / 2)
    ax.set_xticklabels([r["pair"] for r in rows4])
    ax.set_ylabel("Δfloor  (nats/UTF-8 byte)"); ax.legend(fontsize=7, frameon=False, ncol=2)
    ax.set_title("SET 4 · Goldfish eng×X merge · Δfloor vs the better parent (LIKELIHOOD, not accuracy)", fontsize=9)
    fig.tight_layout(); fig.savefig(f"{F}/set4_dfloor.png", bbox_inches="tight"); plt.close(fig)

print("figures + csvs written")

# ------------------------------------------------------------------ 5. BLiMP dissociation
blimp = load("blimp_*.jsonl")
if blimp:
    brows = []
    for b in blimp:
        m1 = {k: v for k, v in b["rungs"].items() if k.startswith("M1")}
        brows.append({"size": b["size"], "pair": tuple(b["pair"]),
                      "ceiling": b["ceiling"], "parent_mean": float(np.mean(list(b["parent_acc"].values()))),
                      "M0": b["rungs"]["M0_naive_avg"]["blimp_acc"],
                      "M1best": max(v["blimp_acc"] for v in m1.values()),
                      **{f"acc_{k}": v["blimp_acc"] for k, v in b["rungs"].items()}})
    to_csv(brows, f"{R}/blimp_pairs.csv")
    s1 = {(r["size"], (r["a"], r["b"])): r for r in rows1}
    sizes_b = sorted({b["size"] for b in brows}, key=lambda x: int(x[:-1]))
    fig, axes = plt.subplots(1, 2, figsize=(9, 3.8))
    for sz in sizes_b:
        sub = [b for b in brows if b["size"] == sz]
        xs, ys = [], []
        for b in sub:
            k = (sz, b["pair"])
            if k in s1 and np.isfinite(s1[k]["rescue_nats"]):
                xs.append(s1[k]["rescue_nats"]); ys.append(b["M1best"] - b["M0"])
        if xs:
            axes[0].scatter(xs, ys, s=20, alpha=.75, label=f"pythia-{sz} (n={len(xs)})")
    axes[0].axhline(0, color="k", lw=.7)
    axes[0].set_xlabel("likelihood rescue from alignment  (nats/token removed)")
    axes[0].set_ylabel("accuracy rescue  (BLiMP, M1best − M0)")
    axes[0].set_title("Rescue in nats does NOT buy rescue in accuracy", fontsize=9)
    axes[0].legend(fontsize=7, frameon=False)
    lab, vals = [], []
    for sz in sizes_b:
        sub = [b for b in brows if b["size"] == sz]
        lab.append(f"pythia-{sz}\n(n={len(sub)})")
        vals.append([np.mean([b["parent_mean"] for b in sub]), np.mean([b["M0"] for b in sub]),
                     np.mean([b["acc_M1_perm_avg"] for b in sub]), np.mean([b["acc_M1_orth_avg"] for b in sub])])
    vals = np.array(vals)
    w = 0.2
    for i, nm in enumerate(["parents", "M0 naive", "M1 permutation", "M1 Procrustes"]):
        axes[1].bar(np.arange(len(lab)) + i * w, vals[:, i], width=w, label=nm)
    axes[1].axhline(0.5, color="k", ls="--", lw=.8)
    axes[1].text(0.02, 0.505, "chance", fontsize=7, transform=axes[1].get_yaxis_transform())
    axes[1].set_xticks(np.arange(len(lab)) + 1.5 * w); axes[1].set_xticklabels(lab, fontsize=7)
    axes[1].set_ylim(0.45, None); axes[1].set_ylabel("BLiMP accuracy")
    axes[1].legend(fontsize=7, frameon=False)
    axes[1].set_title("Parents vs merges", fontsize=9)
    fig.suptitle("SET 1 · likelihood recovery vs grammatical competence", fontsize=10)
    fig.tight_layout(); fig.savefig(f"{F}/set1_blimp_dissociation.png", bbox_inches="tight"); plt.close(fig)

# ------------------------------------------------------------------ 6. scale trend
if rows1:
    szs = sorted({r["size"] for r in rows1}, key=lambda s: int(s[:-1]))
    P = {"14m": 14, "31m": 31, "70m": 70, "160m": 160, "410m": 410}
    x = [P[s] for s in szs]
    naive = [np.mean([r["dfloor_M0_naive_avg"] for r in rows1 if r["size"] == s]) for s in szs]
    resc = [np.mean([1 - min(r["dfloor_M1_perm_avg"], r["dfloor_M1_orth_avg"]) / r["dfloor_M0_naive_avg"]
                     for r in rows1 if r["size"] == s]) * 100 for s in szs]
    fig, ax = plt.subplots(figsize=(4.6, 3.6))
    ax.plot(x, naive, "o-", color="#c0392b", label="naive merge Δfloor (nats/token)")
    ax.set_xscale("log"); ax.set_xticks(x); ax.set_xticklabels(szs)
    ax.set_xlabel("PolyPythia size"); ax.set_ylabel("naive Δfloor (nats/token)", color="#c0392b")
    ax2 = ax.twinx(); ax2.plot(x, resc, "s--", color="#2471a3", label="rescue by alignment (%)")
    ax2.set_ylabel("% of naive Δfloor removed by alignment", color="#2471a3"); ax2.grid(False)
    ax.set_title("Both the obstruction AND alignment's purchase\nshrink with scale", fontsize=9)
    fig.tight_layout(); fig.savefig(f"{F}/set1_scale_trend.png", bbox_inches="tight"); plt.close(fig)
print("extra figures written")

# ------------------------------------------------------------------ 7. B-GPT ceiling
bgc = load("bgpt_ceiling.jsonl")
if bgc:
    arms = list(bgc[0]["arms"])
    nice = {"bgpt_joint_bilingual": "B-GPT\njoint bilingual", "goldfish_eng_parent": "Goldfish\neng parent",
            "goldfish_partner_parent": "Goldfish\npartner parent", "merge_M0_naive": "merge\nM0 naive",
            "merge_M1a_vocab": "merge\nM1a vocab"}
    fig, axes = plt.subplots(1, 2, figsize=(10, 3.9))
    langs = [r["lang"].split("_")[0] for r in bgc]
    w = 0.8 / len(arms)
    for i, a in enumerate(arms):
        axes[0].bar(np.arange(len(bgc)) + i * w, [0.5 * (r["arms"][a]["nats_per_byte_eng"] +
                                                          r["arms"][a]["nats_per_byte_x"]) for r in bgc],
                    width=w, label=nice.get(a, a).replace("\n", " "))
        axes[1].bar(np.arange(len(bgc)) + i * w, [0.5 * (r["arms"][a]["multiblimp_eng"] +
                                                          r["arms"][a]["multiblimp_x"]) for r in bgc],
                    width=w, label=nice.get(a, a).replace("\n", " "))
    for ax, yl, ttl in ((axes[0], "nats / UTF-8 byte (lower better)", "Likelihood"),
                        (axes[1], "MultiBLiMP accuracy (higher better)", "Accuracy")):
        ax.set_xticks(np.arange(len(bgc)) + 0.4 - w / 2)
        ax.set_xticklabels([f"eng–{l}" for l in langs])
        ax.set_ylabel(yl, fontsize=8); ax.set_title(ttl, fontsize=9)
    axes[1].axhline(0.5, color="k", ls="--", lw=.8)
    axes[1].set_ylim(0.0, 1.02)
    axes[0].legend(fontsize=6.5, frameon=False, ncol=2)
    fig.suptitle("SET 4 · what success looks like: a jointly-trained bilingual model vs the merges\n"
                 "(all arms re-scored at a matched 128-token context)", fontsize=9)
    fig.tight_layout(); fig.savefig(f"{F}/set4_joint_ceiling.png", bbox_inches="tight"); plt.close(fig)

# ------------------------------------------------------------------ 8. SET 4 likelihood vs accuracy
mbr = load("set4_multiblimp.jsonl")
if mbr and rows4:
    by_lang = {r["lang"]: r for r in rows4}
    fig, ax = plt.subplots(figsize=(5.2, 4))
    for r in mbr:
        s4 = by_lang.get(r["lang"])
        if not s4: continue
        for k in r["rungs"]:
            key = f"delta_floor_eng_{k}"
            if key not in s4: continue
            ax.scatter(s4[key], r["rungs"][k]["mb_eng"], s=28, alpha=.8,
                       label=r["lang"].split("_")[0] if k == "M0_naive_avg" else None)
    ax.scatter([0], [mbr[0]["parents"]["eng_on_mb_eng"]], marker="*", s=200, color="k",
               label="English parent", zorder=5)
    ax.axhline(0.5, color="grey", ls="--", lw=.8)
    ax.text(0.02, 0.505, "chance", fontsize=7, transform=ax.get_yaxis_transform())
    ax.set_xlabel("Δfloor on English text  (nats/byte, LIKELIHOOD)")
    ax.set_ylabel("MultiBLiMP-English  (ACCURACY)")
    ax.set_title("SET 4 · a merge can be destroyed by likelihood\nand still score well above chance",
                 fontsize=9)
    ax.legend(fontsize=7, frameon=False)
    fig.tight_layout(); fig.savefig(f"{F}/set4_likelihood_vs_accuracy.png", bbox_inches="tight"); plt.close(fig)
print("ceiling figures written")