Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_within_label_marker.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Independent recompute (verify lens) of the within-3 label/marker check (CPU only; 2026-10-05).
+
+Generated side: work/sepsis/fold0/<arm>.npz.  T cells: aifi_l1 or aifi_l2 == 'T cell'; label-called proliferating T:
+aifi_l2 == 'Proliferating T cell' within T; cycling: >= 2 of MKI67 TOP2A TYMS CENPF UBE2C BIRC5 with count > 0.
+Observed side: tools/sepsis_states.observed() for the 17 fold-0 donors (read-only loader), binomially thinned per arm
+with that arm's T-parent thin (= the 'ISG-high T' thin: median generated T library / median observed T library),
+seed 20261005; the thinning is also repeated over 50 extra seeds to show its Monte Carlo spread.
+Uncertainty: Wilson 95% intervals per proportion; donor bootstrap (2000 reps, seed 20261005, donors sorted, the same idx
+for both arms) of the matched scratch - pretrained differences.
+Output: verify_recompute_within_label_marker.csv, verify_recompute_within_label_marker_diffs.csv
+"""
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+sys.dont_write_bytecode = True
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import fisher_exact, norm
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+W = PLAN / "work/sepsis/fold0"
+V = PLAN / "out/scratch_vs_lora_20261005"
+PFX = "verify_recompute_within_"
+SEED, B = 20261005, 2000
+CYC = ["MKI67", "TOP2A", "TYMS", "CENPF", "UBE2C", "BIRC5"]
+ARMS = ["zs__raw", "lora_n5__raw", "scratch_n5__raw", "real_lora__raw", "real_full__raw", "scratch_full__raw",
+        "lora_recipe__raw", "scratch_recipe__raw"]
+MAIN = [("5 pairs", "scratch_n5__raw", "lora_n5__raw"),
+        ("58 pairs vs LoRA", "scratch_full__raw", "real_lora__raw"),
+        ("58 pairs vs full FT", "scratch_full__raw", "real_full__raw"),
+        ("recipes", "scratch_recipe__raw", "lora_recipe__raw")]
+
+spec = importlib.util.spec_from_file_location("sepsis_states_ro", PLAN / "tools/sepsis_states.py")
+ss = importlib.util.module_from_spec(spec)
+sys.path.insert(0, str(PLAN / "tools"))
+spec.loader.exec_module(ss)
+
+states = json.loads((PLAN / "tools/states.json").read_text())
+G = {a: np.load(W / f"{a}.npz", allow_pickle=False) for a in ARMS}
+DONORS = sorted(set(G[ARMS[0]]["donor"].astype(str)))
+assert len(DONORS) == 17
+ob = ss.observed(states, DONORS)
+osyms = list(ob["marker_symbols"])
+ocyc = [osyms.index(g) for g in CYC]
+oT = (ob["lab"].aifi_l1.to_numpy() == "T cell") | (ob["lab"].aifi_l2.to_numpy() == "T cell")
+oPT = oT & (ob["lab"].aifi_l2.to_numpy() == "Proliferating T cell")
+odon = ob["donor"]
+oco = ob["markers"][:, ocyc].astype(np.int64)
+olib = ob["lib"]
+
+PD = pd.read_csv(PLAN / "out/sepsis_fold0_per_donor.csv")
+SUMM = pd.read_csv(PLAN / "out/sepsis_fold0_summary.csv")
+
+
+def wilson(k: int, n: int) -> tuple[float, float]:
+    if n == 0:
+        return (np.nan, np.nan)
+    z = norm.ppf(0.975)
+    p = k / n
+    c = (p + z * z / (2 * n)) / (1 + z * z / n)
+    h = z * np.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
+    return (100 * (c - h), 100 * (c + h))
+
+
+def per_donor(don: np.ndarray, T: np.ndarray, PT: np.ndarray, cyc: np.ndarray) -> np.ndarray:
+    """(17, 4): T cells, cycling T cells, PT-label cells, cycling PT-label cells."""
+    out = np.zeros((17, 4))
+    for i, d in enumerate(DONORS):
+        m = don == d
+        out[i] = [(T & m).sum(), (T & m & cyc).sum(), (PT & m).sum(), (PT & m & cyc).sum()]
+    return out
+
+
+rows, PDON = [], {}
+checks = []
+obs_native_cyc = (oco > 0).sum(1) >= 2
+PDON["observed (native)"] = per_donor(odon, oT, oPT, obs_native_cyc)
+for a in ARMS:
+    g = G[a]
+    syms = list(g["marker_symbols"].astype(str))
+    assert syms == osyms, a
+    gT = (g["aifi_l1"].astype(str) == "T cell") | (g["aifi_l2"].astype(str) == "T cell")
+    gPT = gT & (g["aifi_l2"].astype(str) == "Proliferating T cell")
+    gcyc = (g["markers"][:, [syms.index(x) for x in CYC]] > 0).sum(1) >= 2
+    gdon = g["donor"].astype(str)
+    PDON[a] = per_donor(gdon, gT, gPT, gcyc)
+    thin = min(1.0, float(np.median(g["lib_measured"][gT])) / float(np.median(olib[oT])))
+    # cross-checks against the per-donor CSV (T parent counts, PT-label counts) and the summary thin of ISG-high T
+    pdT = PD[(PD.arm == a) & (PD.state == "ISG-high T")].set_index("donor").loc[DONORS]
+    pdPT = PD[(PD.arm == a) & (PD.state == "Proliferating T (label)")].set_index("donor").loc[DONORS]
+    checks.append({"arm": a, "gen_T_match": bool((pdT.gen_parent.to_numpy() == PDON[a][:, 0]).all()),
+                   "obs_T_match": bool((pdT.obs_parent.to_numpy() == PDON["observed (native)"][:, 0]).all()),
+                   "gen_PT_match": bool((pdPT.gen_state.to_numpy() == PDON[a][:, 2]).all()),
+                   "obs_PT_match": bool((pdPT.obs_state.to_numpy() == PDON["observed (native)"][:, 2]).all()),
+                   "thin_recomputed": thin,
+                   "thin_summary_isgT": float(SUMM[(SUMM.arm == a) & (SUMM.state == "ISG-high T")].thin.iloc[0])})
+    tot = PDON[a].sum(0)
+    rows.append({"side": "generated", "arm": a, "thin": np.nan, "n_T": int(tot[0]), "n_T_cycling": int(tot[1]),
+                 "n_PT_label": int(tot[2]), "n_PT_label_cycling": int(tot[3])})
+    # observed thinned to this arm's T depth: main seed, then 50 extra seeds for the Monte Carlo spread
+    rng = np.random.default_rng(SEED)
+    oc = (rng.binomial(oco, thin) > 0).sum(1) >= 2 if thin < 1.0 else obs_native_cyc
+    PDON[f"observed thinned for {a}"] = per_donor(odon, oT, oPT, oc)
+    tot = PDON[f"observed thinned for {a}"].sum(0)
+    mc_pt, mc_t = [], []
+    if thin < 1.0:
+        for s in range(50):
+            r2 = np.random.default_rng(SEED + 1 + s)
+            c2 = (r2.binomial(oco[oT], thin) > 0).sum(1) >= 2
+            mc_t.append(100 * c2.sum() / oT.sum())
+            mc_pt.append(100 * c2[oPT[oT]].sum() / oPT.sum())
+    rows.append({"side": "observed thinned", "arm": a, "thin": thin, "n_T": int(tot[0]), "n_T_cycling": int(tot[1]),
+                 "n_PT_label": int(tot[2]), "n_PT_label_cycling": int(tot[3]),
+                 "mc50_pct_PT_passing_min": min(mc_pt) if mc_pt else np.nan,
+                 "mc50_pct_PT_passing_max": max(mc_pt) if mc_pt else np.nan,
+                 "mc50_pct_T_cycling_min": min(mc_t) if mc_t else np.nan,
+                 "mc50_pct_T_cycling_max": max(mc_t) if mc_t else np.nan})
+tot = PDON["observed (native)"].sum(0)
+rows.append({"side": "observed native", "arm": "-", "thin": 1.0, "n_T": int(tot[0]), "n_T_cycling": int(tot[1]),
+             "n_PT_label": int(tot[2]), "n_PT_label_cycling": int(tot[3])})
+R = pd.DataFrame(rows)
+R["pct_of_PT_label_passing_cycling_rule"] = 100 * R.n_PT_label_cycling / R.n_PT_label
+R["cycling_rule_pct_of_T"] = 100 * R.n_T_cycling / R.n_T
+R[["pt_wilson_lo", "pt_wilson_hi"]] = [wilson(k, n) for k, n in zip(R.n_PT_label_cycling, R.n_PT_label)]
+R[["t_wilson_lo", "t_wilson_hi"]] = [wilson(k, n) for k, n in zip(R.n_T_cycling, R.n_T)]
+R.to_csv(V / f"{PFX}label_marker.csv", index=False)
+C = pd.DataFrame(checks)
+with pd.option_context("display.width", 250, "display.max_columns", 30):
+    print(C.to_string(index=False))
+    print(R.round(3).to_string(index=False))
+
+# matched differences: Fisher exact on pooled counts + donor bootstrap of the pooled-proportion difference
+idx = np.random.default_rng(SEED).integers(0, 17, (B, 17))
+Wm = np.stack([np.bincount(r, minlength=17) for r in idx]).astype(float)
+drows = []
+for name, sa, pa in MAIN:
+    for metric, (kk, nn) in (("pct_PT_label_passing", (3, 2)), ("pct_T_cycling", (1, 0))):
+        Xs, Xp = PDON[sa], PDON[pa]
+        ks, ns, kp, np_ = Xs[:, kk].sum(), Xs[:, nn].sum(), Xp[:, kk].sum(), Xp[:, nn].sum()
+        est = 100 * (ks / ns - kp / np_)
+        bs = 100 * ((Wm @ Xs[:, kk]) / (Wm @ Xs[:, nn]) - (Wm @ Xp[:, kk]) / (Wm @ Xp[:, nn]))
+        lo, hi = np.nanpercentile(bs, [2.5, 97.5])
+        p = fisher_exact([[ks, ns - ks], [kp, np_ - kp]]).pvalue
+        drows.append({"comparison": name, "metric": metric, "scratch_k_n": f"{int(ks)}/{int(ns)}",
+                      "pretrained_k_n": f"{int(kp)}/{int(np_)}", "diff_scratch_minus_pretrained_pp": est,
+                      "donor_boot_lo": lo, "donor_boot_hi": hi, "fisher_p": p})
+D = pd.DataFrame(drows)
+D.to_csv(V / f"{PFX}label_marker_diffs.csv", index=False)
+with pd.option_context("display.width", 250, "display.max_columns", 30):
+    print(D.round(4).to_string(index=False))

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_within_main.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""Independent recompute (verify lens) of the within-cohort scratch-vs-pretrained claims (CPU only; 2026-10-05).
+
+Input: only out/sepsis_fold0_per_donor.csv (plus sepsis_fold0_summary.csv / sepsis_fold0_contrasts.csv as cross-checks
+of the per-donor CSV itself).  No analyst file (within_*.csv) is read.
+
+Pooled ratio per arm and state: r = ((sum gen_state + pc) / sum gen_parent) / ((sum obsthin_state + pc) / sum obs_parent)
+with pc = 0.5 (fidelity |log2 r|) and pc = 0 (plain ratio = summary gen_over_obs).
+D = |log2 r|(scratch arm) - |log2 r|(pretrained arm): > 0 means the pretrained arm is closer to the observed frequency.
+Donor bootstrap: donors sorted by name, idx = default_rng(20261005).integers(0, 17, (2000, 17)), the same idx for both
+arms, all four sums recomputed on donors[idx[b]].  Percentile CI (2.5 / 97.5) and, as a sensitivity, Efron's
+bias-corrected (BC) percentile CI.  Spearman: over donors with both pcts defined; bootstrap Spearman on resampled rows
+(average ranks), undefined replicates reported.
+Outputs (prefix verify_recompute_within_): fidelity.csv, bootstrap.csv, spearman.csv, contrasts.csv, contrast_counts.csv
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import norm, rankdata, spearmanr
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+OUT = PLAN / "out"
+V = OUT / "scratch_vs_lora_20261005"
+PFX = "verify_recompute_within_"
+SEED, B = 20261005, 2000
+
+P = pd.read_csv(OUT / "sepsis_fold0_per_donor.csv")
+SUMM = pd.read_csv(OUT / "sepsis_fold0_summary.csv")
+CON = pd.read_csv(OUT / "sepsis_fold0_contrasts.csv")
+
+ARMS = list(dict.fromkeys(P.arm))
+STATES = list(dict.fromkeys(P.state))
+CTRL = {"ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"}
+RARE = [s for s in STATES if s not in CTRL]
+DONORS = sorted(P.donor.unique())
+assert len(RARE) == 13 and len(DONORS) == 17 and len(ARMS) == 8, (len(RARE), len(DONORS), len(ARMS))
+TRAINED = [a for a in ARMS if a != "zs__raw"]
+MAIN = [("5 pairs", "scratch_n5__raw", "lora_n5__raw"),
+        ("58 pairs vs LoRA", "scratch_full__raw", "real_lora__raw"),
+        ("58 pairs vs full FT", "scratch_full__raw", "real_full__raw"),
+        ("recipes", "scratch_recipe__raw", "lora_recipe__raw")]
+REFC = [("zs ref: 5 pairs", "scratch_n5__raw", "zs__raw"),
+        ("zs ref: 58 pairs", "scratch_full__raw", "zs__raw"),
+        ("zs ref: recipes", "scratch_recipe__raw", "zs__raw")]
+COLS = ["gen_state", "gen_parent", "obsthin_state", "obs_parent"]
+
+# ---- per-donor arrays in DONORS order -------------------------------------------------------------------------
+X = {}
+for (a, s), g in P.groupby(["arm", "state"], sort=False):
+    assert g.donor.is_unique and len(g) == 17, (a, s)
+    X[(a, s)] = g.set_index("donor").loc[DONORS, COLS].to_numpy(float)
+GROUP = P.drop_duplicates("donor").set_index("donor").group
+
+
+def ratio(sums: np.ndarray, pc: float) -> np.ndarray:
+    gs, gp, os_, op = (sums[..., i] for i in range(4))
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return ((gs + pc) / gp) / ((os_ + pc) / op)
+
+
+def fid(sums: np.ndarray, pc: float = 0.5) -> np.ndarray:
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return np.abs(np.log2(ratio(sums, pc)))
+
+
+def pct(arr: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    with np.errstate(divide="ignore", invalid="ignore"):
+        g = np.where(arr[:, 1] > 0, 100 * arr[:, 0] / arr[:, 1], np.nan)
+        o = np.where(arr[:, 3] > 0, 100 * arr[:, 2] / arr[:, 3], np.nan)
+    return g, o
+
+
+# ---- 0. integrity cross-checks of the per-donor CSV ----------------------------------------------------------
+chk = []
+for a in ARMS:
+    for s in STATES:
+        tot = X[(a, s)].sum(0)
+        r0 = float(ratio(tot, 0.0))
+        srow = SUMM[(SUMM.arm == a) & (SUMM.state == s)].iloc[0]
+        g, o = pct(X[(a, s)])
+        m = np.isfinite(g) & np.isfinite(o)
+        rho = spearmanr(g[m], o[m]).correlation
+        chk.append({"arm": a, "state": s, "ratio_recomputed": r0, "summary_gen_over_obs": srow.gen_over_obs,
+                    "rho_recomputed": rho, "summary_spearman": srow.spearman_donors,
+                    "gen_str": f"{int(tot[0]):,} / {int(tot[1]):,}", "summary_gen": srow.gen,
+                    "obs_str": f"{int(tot[2]):,} / {int(tot[3]):,}", "summary_obs": srow.obs_thinned})
+chk = pd.DataFrame(chk)
+bad_r = (chk.ratio_recomputed - chk.summary_gen_over_obs).abs().max()
+bad_rho = (chk.rho_recomputed - chk.summary_spearman).abs().max()
+bad_str = int(((chk.gen_str != chk.summary_gen) | (chk.obs_str != chk.summary_obs)).sum())
+print(f"[check] max |ratio - summary| = {bad_r:.2e}; max |rho - summary| = {bad_rho:.2e}; count-string mismatches = {bad_str}")
+
+# ---- 1. point estimates per arm and state --------------------------------------------------------------------
+rows = []
+for a in ARMS:
+    for s in STATES:
+        tot = X[(a, s)].sum(0)
+        g, o = pct(X[(a, s)])
+        m = np.isfinite(g) & np.isfinite(o)
+        rows.append({"arm": a, "state": s, "rare": s in RARE, "gen_state": int(tot[0]), "gen_parent": int(tot[1]),
+                     "obsthin_state": int(tot[2]), "obs_parent": int(tot[3]),
+                     "ratio_pc0": float(ratio(tot, 0.0)), "ratio_pc05": float(ratio(tot, 0.5)),
+                     "abs_log2_pc05": float(fid(tot, 0.5)), "abs_log2_pc0": float(fid(tot, 0.0)),
+                     "spearman": float(spearmanr(g[m], o[m]).correlation), "n_donors_spearman": int(m.sum())})
+F = pd.DataFrame(rows)
+agg = F[F.rare].groupby("arm").agg(mean_abs_log2_pc05=("abs_log2_pc05", "mean"),
+                                    mean_abs_log2_pc0=("abs_log2_pc0", "mean"),
+                                    mean_spearman=("spearman", "mean")).reindex(ARMS)
+print(agg.round(3).to_string())
+F.to_csv(V / f"{PFX}fidelity.csv", index=False)
+
+# ---- 2. donor bootstrap ----------------------------------------------------------------------------------------
+idx = np.random.default_rng(SEED).integers(0, 17, (B, 17))
+W = np.stack([np.bincount(r, minlength=17) for r in idx]).astype(float)  # (B, 17) donor multiplicities
+BOOT = {k: W @ v for k, v in X.items()}  # (B, 4) resampled sums
+
+
+def bc_ci(boot: np.ndarray, est: float, ties: bool = False) -> tuple[float, float]:
+    b = boot[np.isfinite(boot)]
+    if not np.isfinite(est) or len(b) == 0:
+        return (np.nan, np.nan)
+    p = (np.sum(b < est) + (0.5 * np.sum(b == est) if ties else 0.0)) / len(b)
+    if p <= 0 or p >= 1:
+        return (np.nan, np.nan)
+    z0 = norm.ppf(p)
+    lo, hi = norm.cdf(2 * z0 + norm.ppf(0.025)), norm.cdf(2 * z0 + norm.ppf(0.975))
+    return tuple(np.percentile(b, [100 * lo, 100 * hi]))
+
+
+def verdict(lo: float, hi: float) -> str:
+    if not (np.isfinite(lo) and np.isfinite(hi)):
+        return "undefined"
+    if lo > 0:
+        return "pretrained closer"
+    if hi < 0:
+        return "scratch closer"
+    return "n.s."
+
+
+brows = []
+for kind, comps in (("main", MAIN), ("reference", REFC)):
+    for name, sa, pa in comps:
+        Dst, Dbs = {}, {}
+        for s in STATES:
+            Dst[s] = float(fid(X[(sa, s)].sum(0)) - fid(X[(pa, s)].sum(0)))
+            Dbs[s] = fid(BOOT[(sa, s)]) - fid(BOOT[(pa, s)])
+        for s in STATES + ["MEAN13"]:
+            if s == "MEAN13":
+                est = float(np.mean([Dst[t] for t in RARE]))
+                boot = np.mean(np.stack([Dbs[t] for t in RARE], 1), 1)
+                fs = float(np.mean([fid(X[(sa, t)].sum(0)) for t in RARE]))
+                fp = float(np.mean([fid(X[(pa, t)].sum(0)) for t in RARE]))
+                rs = rp = np.nan
+            else:
+                est, boot = Dst[s], Dbs[s]
+                fs, fp = float(fid(X[(sa, s)].sum(0))), float(fid(X[(pa, s)].sum(0)))
+                rs, rp = float(ratio(X[(sa, s)].sum(0), 0.0)), float(ratio(X[(pa, s)].sum(0), 0.0))
+            fin = np.isfinite(boot)
+            lo, hi = np.percentile(boot[fin], [2.5, 97.5])
+            blo, bhi = bc_ci(boot, est)
+            tlo, thi = bc_ci(boot, est, ties=True)
+            brows.append({"kind": kind, "comparison": name, "scratch_arm": sa, "pretrained_arm": pa, "state": s,
+                          "rare": s in RARE or s == "MEAN13", "ratio_scratch_pc0": rs, "ratio_pretrained_pc0": rp,
+                          "abs_log2_scratch": fs, "abs_log2_pretrained": fp, "D": est,
+                          "D_ci_lo": lo, "D_ci_hi": hi, "D_bc_ci_lo": blo, "D_bc_ci_hi": bhi,
+                          "D_bc_ties_lo": tlo, "D_bc_ties_hi": thi, "boot_mean": float(np.mean(boot[fin])),
+                          "boot_frac_below_est": float(np.mean(boot[fin] < est)), "n_finite": int(fin.sum()),
+                          "verdict_pct": verdict(lo, hi), "verdict_bc": verdict(blo, bhi)})
+BT = pd.DataFrame(brows)
+BT.to_csv(V / f"{PFX}bootstrap.csv", index=False)
+with pd.option_context("display.width", 250, "display.max_rows", 500, "display.max_columns", 30):
+    show = ["comparison", "state", "ratio_scratch_pc0", "ratio_pretrained_pc0", "abs_log2_scratch",
+            "abs_log2_pretrained", "D", "D_ci_lo", "D_ci_hi", "D_bc_ci_lo", "D_bc_ci_hi", "verdict_pct", "verdict_bc"]
+    print(BT[show].round(3).to_string(index=False))
+    m = BT[(BT.state != "MEAN13") & BT.rare]
+    print(m.groupby(["kind", "comparison"], sort=False).verdict_pct.value_counts().unstack(fill_value=0))
+    print(m.groupby(["kind", "comparison"], sort=False).verdict_bc.value_counts().unstack(fill_value=0))
+
+# ---- 3. Spearman point + bootstrap --------------------------------------------------------------------------------
+
+
+def boot_spearman(g: np.ndarray, o: np.ndarray) -> np.ndarray:
+    gb, ob = g[idx], o[idx]
+    out = np.full(B, np.nan)
+    if np.isfinite(g).all() and np.isfinite(o).all():
+        rg, ro = rankdata(gb, axis=1), rankdata(ob, axis=1)
+        rg -= rg.mean(1, keepdims=True)
+        ro -= ro.mean(1, keepdims=True)
+        den = np.sqrt((rg ** 2).sum(1) * (ro ** 2).sum(1))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            out = np.where(den > 0, (rg * ro).sum(1) / den, np.nan)
+        return out
+    for b in range(B):
+        m = np.isfinite(gb[b]) & np.isfinite(ob[b])
+        x, y = gb[b][m], ob[b][m]
+        if m.sum() > 2 and np.ptp(x) > 0 and np.ptp(y) > 0:
+            out[b] = spearmanr(x, y).correlation
+    return out
+
+
+SP = {}
+for a in ARMS:
+    for s in STATES:
+        g, o = pct(X[(a, s)])
+        SP[(a, s)] = boot_spearman(g, o)
+
+srows = []
+for kind, comps in (("main", MAIN), ("reference", REFC)):
+    for name, sa, pa in comps:
+        for s in STATES + ["MEAN13"]:
+            if s == "MEAN13":
+                rs = float(np.mean([F[(F.arm == sa) & (F.state == t)].spearman.iloc[0] for t in RARE]))
+                rp = float(np.mean([F[(F.arm == pa) & (F.state == t)].spearman.iloc[0] for t in RARE]))
+                Ms = np.stack([SP[(sa, t)] for t in RARE], 1)
+                Mp = np.stack([SP[(pa, t)] for t in RARE], 1)
+                d = Mp - Ms
+                boot = np.mean(d, 1)
+                boot_nan = np.nanmean(d, 1)
+            else:
+                rs = float(F[(F.arm == sa) & (F.state == s)].spearman.iloc[0])
+                rp = float(F[(F.arm == pa) & (F.state == s)].spearman.iloc[0])
+                boot = SP[(pa, s)] - SP[(sa, s)]
+                boot_nan = boot
+            fin = np.isfinite(boot)
+            lo, hi = np.percentile(boot[fin], [2.5, 97.5])
+            lo2, hi2 = np.percentile(boot_nan[np.isfinite(boot_nan)], [2.5, 97.5])
+            srows.append({"kind": kind, "comparison": name, "scratch_arm": sa, "pretrained_arm": pa, "state": s,
+                          "rare": s in RARE or s == "MEAN13", "rho_scratch": rs, "rho_pretrained": rp,
+                          "diff_pre_minus_scratch": rp - rs, "ci_lo": lo, "ci_hi": hi, "n_finite": int(fin.sum()),
+                          "ci_lo_nanmean": lo2, "ci_hi_nanmean": hi2,
+                          "verdict": ("pretrained tracks better" if lo > 0 else
+                                      "scratch tracks better" if hi < 0 else "n.s.")})
+SPT = pd.DataFrame(srows)
+SPT.to_csv(V / f"{PFX}spearman.csv", index=False)
+with pd.option_context("display.width", 250, "display.max_rows", 500, "display.max_columns", 30):
+    print(SPT[["kind", "comparison", "state", "rho_scratch", "rho_pretrained", "diff_pre_minus_scratch", "ci_lo",
+               "ci_hi", "n_finite", "ci_lo_nanmean", "ci_hi_nanmean", "verdict"]].round(3).to_string(index=False))
+    m = SPT[(SPT.state != "MEAN13") & SPT.rare]
+    print(m.groupby(["kind", "comparison"], sort=False).verdict.value_counts().unstack(fill_value=0))
+
+# ---- 4. disease contrasts (from the per-donor CSV group column) ----------------------------------------------
+CONTRASTS = [("adult sepsis vs adult HC", ["adult_sepsis"], ["adult_HC"]),
+             ("paediatric sepsis vs paediatric HC", ["ped_sepsis"], ["ped_HC"]),
+             ("all sepsis vs all controls", ["adult_sepsis", "ped_sepsis"],
+              ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])]
+gv = GROUP.loc[DONORS].to_numpy()
+print("groups:", pd.Series(gv).value_counts().to_dict())
+crow = []
+for a in ARMS:
+    for s in STATES:
+        g, o = pct(X[(a, s)])
+        for name, A, Bg in CONTRASTS:
+            ma, mb = np.isin(gv, A), np.isin(gv, Bg)
+            od = np.nanmean(o[ma]) - np.nanmean(o[mb])
+            gd = np.nanmean(g[ma]) - np.nanmean(g[mb])
+            crow.append({"arm": a, "state": s, "contrast": name, "n_a": int(ma.sum()), "n_b": int(mb.sum()),
+                         "obs_diff": od, "gen_diff": gd})
+CT = pd.DataFrame(crow)
+mrg = CT.merge(CON[["arm", "state", "contrast", "obs_diff", "gen_diff"]], on=["arm", "state", "contrast"],
+               suffixes=("", "_file"))
+print(f"[check] contrasts: max |obs_diff - file| = {(mrg.obs_diff - mrg.obs_diff_file).abs().max():.2e}, "
+      f"max |gen_diff - file| = {(mrg.gen_diff - mrg.gen_diff_file).abs().max():.2e}")
+elig = []
+for s in RARE:
+    for name, _, _ in CONTRASTS:
+        od = CT[(CT.state == s) & (CT.contrast == name) & CT.arm.isin(TRAINED)].obs_diff.to_numpy()
+        sg = np.sign(od)
+        ok = bool(np.abs(od).min() >= 0.5 and (sg == sg[0]).all() and sg[0] != 0)
+        elig.append({"state": s, "contrast": name, "eligible": ok, "min_abs_obs_diff": float(np.abs(od).min()),
+                     "obs_sign": int(sg[0]) if (sg == sg[0]).all() else 0})
+EL = pd.DataFrame(elig)
+CT = CT.merge(EL, on=["state", "contrast"], how="left")
+CT["kept"] = np.sign(CT.gen_diff) == np.sign(CT.obs_diff)
+CT["loss_type"] = np.where(CT.kept, "kept",
+                           np.where(~np.isfinite(CT.gen_diff) | (CT.gen_diff == 0), "flat",
+                                    np.where(CT.gen_diff.abs() >= 0.5, "reversed_strong", "reversed_weak")))
+with np.errstate(divide="ignore", invalid="ignore"):
+    CT["gen_over_obs_diff"] = CT.gen_diff / CT.obs_diff
+CT.to_csv(V / f"{PFX}contrasts.csv", index=False)
+E = CT[CT.eligible.fillna(False).astype(bool)]
+print("eligible pairs:", int(EL.eligible.sum()))
+cc = E.groupby("arm").loss_type.value_counts().unstack(fill_value=0).reindex(ARMS)
+cc["n"] = cc.sum(1)
+cc.to_csv(V / f"{PFX}contrast_counts.csv")
+print(cc)
+with pd.option_context("display.width", 250, "display.max_rows", 500, "display.max_columns", 30):
+    print(E[~E.kept & E.arm.isin(TRAINED)][["arm", "state", "contrast", "obs_diff", "gen_diff", "loss_type",
+                                            "gen_over_obs_diff"]].round(3).sort_values(["arm", "state"]).to_string(index=False))
+    att = E[E.arm.isin(ARMS)].assign(abs_ratio=lambda d: (d.gen_diff / d.obs_diff))
+    print(att.groupby("arm").abs_ratio.median().reindex(ARMS).round(3))

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/verify_recompute_within_sensitivity.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Adversarial sensitivity checks for the within-cohort claims (verify lens; CPU only; 2026-10-05).
+
+From out/sepsis_fold0_per_donor.csv only (same pooled-ratio fidelity, pseudocount 0.5, and the same donor bootstrap
+idx = default_rng(20261005).integers(0, 17, (2000, 17)) over donors sorted by name):
+  1. mean D over state subsets: all 13 rare states; 11 marker-defined states (drop the two scANVI-label states);
+     10 states (also drop LDG); and per comparison the states that are not a 'double failure'
+     (dropping states where both arms are outside [0.5x, 2x]).
+  2. Spearman mean difference (pretrained - scratch) with Efron bias-corrected CIs (sensitivity to within-7).
+  3. Disease-direction counts: discordant eligible pairs per matched comparison with an exact two-sided sign
+     (McNemar) test, ignoring the dependence between pairs (so p-values are optimistic).
+Output: verify_recompute_within_sensitivity.csv, verify_recompute_within_direction_mcnemar.csv
+"""
+from __future__ import annotations
+
+import os
+
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import binomtest, norm, rankdata
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+OUT = PLAN / "out"
+V = OUT / "scratch_vs_lora_20261005"
+PFX = "verify_recompute_within_"
+SEED, B = 20261005, 2000
+P = pd.read_csv(OUT / "sepsis_fold0_per_donor.csv")
+STATES = list(dict.fromkeys(P.state))
+CTRL = {"ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"}
+RARE = [s for s in STATES if s not in CTRL]
+LABEL = ["Proliferating T (label)", "Plasmablast (label)"]
+LDG = "Granulocyte-like (LDG)"
+DONORS = sorted(P.donor.unique())
+MAIN = [("5 pairs", "scratch_n5__raw", "lora_n5__raw"),
+        ("58 pairs vs LoRA", "scratch_full__raw", "real_lora__raw"),
+        ("58 pairs vs full FT", "scratch_full__raw", "real_full__raw"),
+        ("recipes", "scratch_recipe__raw", "lora_recipe__raw")]
+REFC = [("zs ref: 5 pairs", "scratch_n5__raw", "zs__raw"),
+        ("zs ref: 58 pairs", "scratch_full__raw", "zs__raw"),
+        ("zs ref: recipes", "scratch_recipe__raw", "zs__raw")]
+X = {(a, s): g.set_index("donor").loc[DONORS, ["gen_state", "gen_parent", "obsthin_state", "obs_parent"]]
+     .to_numpy(float) for (a, s), g in P.groupby(["arm", "state"])}
+idx = np.random.default_rng(SEED).integers(0, 17, (B, 17))
+Wm = np.stack([np.bincount(r, minlength=17) for r in idx]).astype(float)
+
+
+def fid(S: np.ndarray) -> np.ndarray:
+    return np.abs(np.log2(((S[..., 0] + 0.5) / S[..., 1]) / ((S[..., 2] + 0.5) / S[..., 3])))
+
+
+def ratio0(S: np.ndarray) -> float:
+    return float((S[0] / S[1]) / (S[2] / S[3]))
+
+
+def bc(boot: np.ndarray, est: float) -> tuple[float, float]:
+    b = boot[np.isfinite(boot)]
+    p = np.mean(b < est)
+    if p <= 0 or p >= 1:
+        return (np.nan, np.nan)
+    z0 = norm.ppf(p)
+    return tuple(np.percentile(b, [100 * norm.cdf(2 * z0 - 1.959964), 100 * norm.cdf(2 * z0 + 1.959964)]))
+
+
+rows = []
+for kind, comps in (("main", MAIN), ("reference", REFC)):
+    for name, sa, pa in comps:
+        d_est = {s: float(fid(X[(sa, s)].sum(0)) - fid(X[(pa, s)].sum(0))) for s in RARE}
+        d_bt = {s: fid(Wm @ X[(sa, s)]) - fid(Wm @ X[(pa, s)]) for s in RARE}
+        both_fail = [s for s in RARE if all(not (0.5 <= ratio0(X[(a, s)].sum(0)) <= 2.0) for a in (sa, pa))]
+        subsets = {"13 rare states": RARE,
+                   "11 marker states (drop 2 label states)": [s for s in RARE if s not in LABEL],
+                   "10 states (drop 2 label states + LDG)": [s for s in RARE if s not in LABEL + [LDG]],
+                   "drop double failures (both outside 0.5-2x)": [s for s in RARE if s not in both_fail],
+                   "drop label states + double failures": [s for s in RARE if s not in LABEL + both_fail]}
+        for lab, ss in subsets.items():
+            est = float(np.mean([d_est[s] for s in ss]))
+            boot = np.mean(np.stack([d_bt[s] for s in ss], 1), 1)
+            lo, hi = np.percentile(boot, [2.5, 97.5])
+            blo, bhi = bc(boot, est)
+            rows.append({"analysis": "fidelity mean D", "kind": kind, "comparison": name, "subset": lab,
+                         "n_states": len(ss), "dropped": "; ".join(s for s in RARE if s not in ss), "D": est,
+                         "ci_lo": lo, "ci_hi": hi, "bc_lo": blo, "bc_hi": bhi})
+
+
+# ---- Spearman mean difference with BC CI ----
+def pcts(A: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    with np.errstate(divide="ignore", invalid="ignore"):
+        return (np.where(A[:, 1] > 0, A[:, 0] / A[:, 1], np.nan), np.where(A[:, 3] > 0, A[:, 2] / A[:, 3], np.nan))
+
+
+def rho(g: np.ndarray, o: np.ndarray) -> float:
+    m = np.isfinite(g) & np.isfinite(o)
+    if m.sum() < 3:
+        return np.nan
+    a, b = rankdata(g[m]), rankdata(o[m])
+    a, b = a - a.mean(), b - b.mean()
+    den = np.sqrt((a * a).sum() * (b * b).sum())
+    return float((a * b).sum() / den) if den > 0 else np.nan
+
+
+RB = {}
+for a in {x for _, s_, p_ in MAIN + REFC for x in (s_, p_)}:
+    for s in RARE:
+        g, o = pcts(X[(a, s)])
+        RB[(a, s)] = (rho(g, o), np.array([rho(g[i], o[i]) for i in idx]))
+for kind, comps in (("main", MAIN), ("reference", REFC)):
+    for name, sa, pa in comps:
+        est = float(np.mean([RB[(pa, s)][0] - RB[(sa, s)][0] for s in RARE]))
+        boot = np.nanmean(np.stack([RB[(pa, s)][1] - RB[(sa, s)][1] for s in RARE], 1), 1)
+        lo, hi = np.percentile(boot, [2.5, 97.5])
+        blo, bhi = bc(boot, est)
+        rows.append({"analysis": "Spearman mean diff (pre - scratch)", "kind": kind, "comparison": name,
+                     "subset": "13 rare states", "n_states": 13, "dropped": "", "D": est, "ci_lo": lo, "ci_hi": hi,
+                     "bc_lo": blo, "bc_hi": bhi})
+R = pd.DataFrame(rows)
+R.to_csv(V / f"{PFX}sensitivity.csv", index=False)
+with pd.option_context("display.width", 250, "display.max_rows", 200, "display.max_colwidth", 70):
+    print(R.drop(columns=["dropped"]).round(3).to_string(index=False))
+    print(R[R.subset.str.startswith("drop")][["comparison", "subset", "dropped"]].to_string(index=False))
+
+# ---- disease-direction discordance (eligible pairs from the verify contrasts table) ----
+CT = pd.read_csv(V / f"{PFX}contrasts.csv")
+E = CT[CT.eligible.fillna(False).astype(bool)]
+mrows = []
+for name, sa, pa in MAIN + REFC:
+    ks = E[E.arm == sa].set_index(["state", "contrast"]).kept
+    kp = E[E.arm == pa].set_index(["state", "contrast"]).kept.reindex(ks.index)
+    b = int((kp & ~ks).sum())   # pretrained kept, scratch lost
+    c = int((~kp & ks).sum())   # scratch kept, pretrained lost
+    p = binomtest(b, b + c, 0.5).pvalue if b + c > 0 else np.nan
+    mrows.append({"comparison": name, "scratch_arm": sa, "pretrained_arm": pa, "n_eligible": len(ks),
+                  "kept_scratch": int(ks.sum()), "kept_pretrained": int(kp.sum()), "pre_only": b, "scratch_only": c,
+                  "exact_sign_p_two_sided": p})
+M = pd.DataFrame(mrows)
+M.to_csv(V / f"{PFX}direction_mcnemar.csv", index=False)
+print(M.round(4).to_string(index=False))

paper-releases/pbisc-diffusion/updates/20261005T142225Z-rare-states-scratch-vs-pretrained/diffusion/dataset/server_1/model8/plans/rare_states_screen_20261004/out/scratch_vs_lora_20261005/within_analysis.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""Rare-state fidelity, from-scratch vs pretrained arms, WITHIN-COHORT setting (2026-10-05; CPU only).
+
+Setting: Ye 2026 sepsis paired cohort, fold 0, 17 held-out donors (12 sepsis, 5 controls).  Inputs (read-only) are
+the fold-0 outputs of tools/sepsis_states.py (--scope fold0 analyze) one directory up:
+    ../sepsis_fold0_summary.csv, ../sepsis_fold0_contrasts.csv, ../sepsis_fold0_per_donor.csv
+Outputs (new files, this directory, prefix "within_"):
+    within_state_table.csv           one row per state: gen_over_obs, |log2|, Spearman, cell counts for all 8 arms
+    within_arm_fidelity.csv          per arm x state: pooled log2 ratio (+0.5) with donor-bootstrap 95 % CI
+    within_bootstrap.csv             per comparison x state: D = |log2 r_scratch| - |log2 r_pretrained|, CI, verdict
+    within_bootstrap_counts.csv      per comparison: verdict counts (rare states; controls separately)
+    within_contrast_directions.csv   per arm x (state, contrast): observed vs generated difference, kept/reversed/flat
+    within_contrast_counts.csv       per arm: kept / reversed / flat counts on the common eligible set
+    within_spearman.csv              per comparison x state: Spearman over donors, difference with bootstrap CI
+
+Definitions
+- Pooled ratio of an arm and state, as in the summary CSV:
+      r = (sum gen_state / sum gen_parent) / (sum obsthin_state / sum obs_parent)
+  For log2 work +0.5 is added to both state counts (r_pc).  Fidelity = |log2 r_pc| (0 = generated frequency equals the
+  observed frequency after thinning to the arm's depth).
+- D = |log2 r_pc(scratch)| - |log2 r_pc(pretrained)|.  D > 0: the pretrained arm is closer to the observed frequency.
+- Paired donor bootstrap: one 2000 x 17 index matrix, np.random.default_rng(20261005).integers(0, 17, (2000, 17)) over
+  the donors sorted by name, reused for every arm, state and comparison (so arms, states and comparisons are paired).
+  95 % percentile intervals.  "pretrained closer" if the CI of D lies above 0, "scratch closer" if it lies below 0.
+  p_boot = 2 * min(P(D_b <= 0), P(D_b >= 0)) (rough two-sided bootstrap p, not multiplicity-corrected).
+  Sensitivity only: bias-corrected percentile interval of D (columns D_bc_*), because |log2| is folded at 0.
+  Companion script within_label_marker_check.py (label vs marker definition of proliferating T cells).
+- Informative state: the observed side has >= 30 thinned state cells in total in every arm (minimum over arms).
+- Contrast eligibility (common to all arms): informative non-control state and |obs_diff| >= 0.5 percentage points in
+  each of the 7 trained arms with the same observed sign (obs_diff varies slightly by arm through thinning).
+  status: kept (sign(gen_diff) == sign(obs_diff)), flat (gen_diff == 0 or undefined), reversed (opposite sign).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import norm, rankdata
+
+OUT = Path(__file__).resolve().parent
+SRC = OUT.parent
+SEED, NBOOT, PC = 20261005, 2000, 0.5
+INFORMATIVE_MIN = 30
+CONTRAST_MIN = 0.5
+
+ARMS = ["zs__raw", "lora_n5__raw", "scratch_n5__raw", "real_lora__raw", "real_full__raw", "scratch_full__raw",
+        "lora_recipe__raw", "scratch_recipe__raw"]
+ARM_INFO = {  # init, pairs, training minutes (fold 0; from the task description / benchmark)
+    "zs__raw": ("pretrained zero-shot", 0, 0.0),
+    "lora_n5__raw": ("pretrained + LoRA", 5, 3.2),
+    "scratch_n5__raw": ("scratch", 5, 61.0),
+    "real_lora__raw": ("pretrained + LoRA", 58, 5.4),
+    "real_full__raw": ("pretrained + full FT", 58, 4.7),
+    "scratch_full__raw": ("scratch (100k-step cap)", 58, 79.0),
+    "lora_recipe__raw": ("pretrained + LoRA + recipes", 58, 4.5),
+    "scratch_recipe__raw": ("scratch + recipes", 58, 86.0),
+}
+TRAINED = [a for a in ARMS if a != "zs__raw"]
+SCRATCH_ARMS = ["scratch_n5__raw", "scratch_full__raw", "scratch_recipe__raw"]
+COMPARISONS = [  # name, scratch arm, pretrained arm, kind
+    ("5 pairs: scratch vs pretrained LoRA", "scratch_n5__raw", "lora_n5__raw", "main"),
+    ("58 pairs: scratch vs pretrained LoRA", "scratch_full__raw", "real_lora__raw", "main"),
+    ("58 pairs: scratch vs pretrained full FT", "scratch_full__raw", "real_full__raw", "main"),
+    ("58 pairs + recipes: scratch vs pretrained LoRA", "scratch_recipe__raw", "lora_recipe__raw", "main"),
+    ("reference: scratch 5 pairs vs pretrained zero-shot (no pairs)", "scratch_n5__raw", "zs__raw", "reference"),
+    ("reference: scratch 58 pairs vs pretrained zero-shot (no pairs)", "scratch_full__raw", "zs__raw", "reference"),
+    ("reference: scratch 58 + recipes vs pretrained zero-shot (no pairs)", "scratch_recipe__raw", "zs__raw",
+     "reference"),
+]
+CONTROLS = {"ISG-high monocyte (positive control)": "positive control",
+            "Platelet signal in monocytes (negative control)": "negative control"}
+KEYS = ["gen_state", "gen_parent", "obsthin_state", "obs_parent", "obs_state", "gen_pct", "obsthin_pct"]
+
+
+def r6(x):
+    return None if x is None or (isinstance(x, float) and not np.isfinite(x)) else round(float(x), 6)
+
+
+def load():
+    P = pd.read_csv(SRC / "sepsis_fold0_per_donor.csv")
+    S = pd.read_csv(SRC / "sepsis_fold0_summary.csv")
+    C = pd.read_csv(SRC / "sepsis_fold0_contrasts.csv")
+    assert sorted(P.arm.unique()) == sorted(ARMS), P.arm.unique()
+    return P, S, C
+
+
+def arrays(P, donors, states):
+    A = {}
+    for (arm, st), t in P.groupby(["arm", "state"]):
+        t = t.set_index("donor").loc[donors]
+        A[arm, st] = {k: t[k].to_numpy(float) for k in KEYS}
+    assert all((a, s) in A for a in ARMS for s in states)
+    return A
+
+
+def log2_ratio(x, idx=None):
+    """Pooled log2 ratio (+0.5 on state counts); idx (B, n) -> (B,) bootstrap values."""
+    tot = {k: (x[k].sum() if idx is None else x[k][idx].sum(axis=-1))
+           for k in ["gen_state", "gen_parent", "obsthin_state", "obs_parent"]}
+    with np.errstate(divide="ignore", invalid="ignore"):
+        v = np.log2(((tot["gen_state"] + PC) / tot["gen_parent"]) / ((tot["obsthin_state"] + PC) / tot["obs_parent"]))
+    return np.where(np.isfinite(v), v, np.nan)
+
+
+def spearman(x, y):
+    m = np.isfinite(x) & np.isfinite(y)
+    if m.sum() < 3:
+        return np.nan
+    rx, ry = rankdata(x[m]), rankdata(y[m])
+    if rx.std() == 0 or ry.std() == 0:
+        return np.nan
+    return float(np.corrcoef(rx, ry)[0, 1])
+
+
+def boot_spearman(x, IDX):
+    g, o = x["gen_pct"], x["obsthin_pct"]
+    return np.array([spearman(g[i], o[i]) for i in IDX])
+
+
+def ci(v):
+    v = v[np.isfinite(v)]
+    if len(v) == 0:
+        return np.nan, np.nan, 0
+    lo, hi = np.percentile(v, [2.5, 97.5])
+    return lo, hi, len(v)
+
+
+def p_boot(v):
+    v = v[np.isfinite(v)]
+    if len(v) == 0:
+        return np.nan
+    return min(1.0, 2 * min((v <= 0).mean(), (v >= 0).mean()))
+
+
+def verdict(lo, hi, pos="pretrained closer", neg="scratch closer"):
+    if not (np.isfinite(lo) and np.isfinite(hi)):
+        return "undefined"
+    return pos if lo > 0 else neg if hi < 0 else "not significant"
+
+
+def bc_ci(v, t0):
+    """Bias-corrected percentile interval (sensitivity only).  |log2| is folded at 0, so when one arm sits near 1x its
+    bootstrap |log2| is pushed above the point estimate and the plain percentile interval of D is shifted; the BC
+    interval re-centres on the point estimate (z0 = Phi^-1(P(D_b < D)))."""
+    v = v[np.isfinite(v)]
+    if len(v) == 0 or not np.isfinite(t0):
+        return np.nan, np.nan
+    z0 = norm.ppf(np.clip((v < t0).mean() + 0.5 * (v == t0).mean(), 1e-4, 1 - 1e-4))
+    q = norm.cdf(2 * z0 + norm.ppf([0.025, 0.975]))
+    lo, hi = np.percentile(v, 100 * q)
+    return lo, hi
+
+
+def main():
+    P, S, C = load()
+    donors = sorted(P.donor.unique())
+    states = list(dict.fromkeys(S.state))
+    A = arrays(P, donors, states)
+    rng = np.random.default_rng(SEED)
+    IDX = rng.integers(0, len(donors), size=(NBOOT, len(donors)))
+    groups = P.drop_duplicates("donor").set_index("donor").group
+
+    # ---------------- 1. state table -----------------------------------------------------------------------------
+    Sx = S.set_index(["arm", "state"])
+    obsthin_tot = {(a, s): int(A[a, s]["obsthin_state"].sum()) for a in ARMS for s in states}
+    informative = {s: min(obsthin_tot[a, s] for a in ARMS) >= INFORMATIVE_MIN for s in states}
+    rows = []
+    for s in states:
+        x0 = A[ARMS[0], s]
+        native = x0["obs_state"]
+        row = {"state": s, "role": CONTROLS.get(s, "rare state"),
+               "obs_parent_cells": int(x0["obs_parent"].sum()), "obs_native_state_cells": int(native.sum()),
+               "obs_thinned_state_cells_min": min(obsthin_tot[a, s] for a in ARMS),
+               "obs_thinned_state_cells_max": max(obsthin_tot[a, s] for a in ARMS),
+               "informative": informative[s],
+               "obs_donors_with_state": int((native > 0).sum()),
+               "obs_top_donor_share": r6(native.max() / native.sum()) if native.sum() else None,
+               "obs_top_donor": donors[int(np.argmax(native))]}
+        fid = {}
+        for a in ARMS:
+            g = Sx.loc[(a, s)]
+            ratio = float(g.gen_over_obs)
+            row[f"gen_over_obs__{a}"] = r6(ratio)
+            row[f"abs_log2__{a}"] = r6(abs(np.log2(ratio))) if ratio > 0 else None
+            row[f"spearman__{a}"] = r6(g.spearman_donors)
+            row[f"gen_state_cells__{a}"] = int(A[a, s]["gen_state"].sum())
+            row[f"gen_parent_cells__{a}"] = int(A[a, s]["gen_parent"].sum())
+            row[f"obs_thinned_state_cells__{a}"] = obsthin_tot[a, s]
+            row[f"thin__{a}"] = r6(g.thin)
+            fid[a] = abs(np.log2(ratio)) if ratio > 0 else np.inf
+        best = min(TRAINED, key=lambda a: fid[a])
+        row["closest_trained_arm"] = best
+        row["closest_scratch_arm"] = min(SCRATCH_ARMS, key=lambda a: fid[a])
+        row["closest_pretrained_trained_arm"] = min([a for a in TRAINED if a not in SCRATCH_ARMS], key=lambda a: fid[a])
+        rows.append(row)
+    ST = pd.DataFrame(rows)
+    ST.to_csv(OUT / "within_state_table.csv", index=False)
+
+    # ---------------- 2. bootstrap of |log2| ---------------------------------------------------------------------
+    L0 = {(a, s): float(log2_ratio(A[a, s])) for a in ARMS for s in states}
+    LB = {(a, s): log2_ratio(A[a, s], IDX) for a in ARMS for s in states}
+    fr = []
+    for a in ARMS:
+        for s in states:
+            lo, hi, n = ci(LB[a, s])
+            alo, ahi, _ = ci(np.abs(LB[a, s]))
+            fr.append({"arm": a, "init": ARM_INFO[a][0], "pairs": ARM_INFO[a][1], "state": s,
+                       "role": CONTROLS.get(s, "rare state"), "informative": informative[s],
+                       "gen_over_obs_summary": r6(Sx.loc[(a, s)].gen_over_obs),
+                       "ratio_pc": r6(2 ** L0[a, s]), "log2_ratio_pc": r6(L0[a, s]),
+                       "log2_ci_lo": r6(lo), "log2_ci_hi": r6(hi),
+                       "ratio_ci_lo": r6(2 ** lo), "ratio_ci_hi": r6(2 ** hi),
+                       "ratio_ci_includes_1": bool(lo <= 0 <= hi), "abs_log2_pc": r6(abs(L0[a, s])),
+                       "abs_log2_ci_lo": r6(alo), "abs_log2_ci_hi": r6(ahi), "n_boot_valid": n})
+    rare = [s for s in states if s not in CONTROLS and informative[s]]
+    for a in ARMS:  # mean |log2| over the informative rare states
+        m0 = np.mean([abs(L0[a, s]) for s in rare])
+        mb = np.mean(np.vstack([np.abs(LB[a, s]) for s in rare]), axis=0)
+        lo, hi, n = ci(mb)
+        n_in = sum(bool(ci(LB[a, s])[0] <= 0 <= ci(LB[a, s])[1]) for s in rare)
+        fr.append({"arm": a, "init": ARM_INFO[a][0], "pairs": ARM_INFO[a][1],
+                   "state": f"MEAN over {len(rare)} informative rare states", "role": "aggregate",
+                   "informative": True, "abs_log2_pc": r6(m0), "abs_log2_ci_lo": r6(lo), "abs_log2_ci_hi": r6(hi),
+                   "n_boot_valid": n, "ratio_ci_includes_1": None,
+                   "n_rare_states_ratio_ci_includes_1": n_in,
+                   "n_rare_states_within_2x": sum(abs(L0[a, s]) <= 1 for s in rare),
+                   "n_rare_states_below_0.25x": sum(L0[a, s] < -2 for s in rare)})
+    pd.DataFrame(fr).to_csv(OUT / "within_arm_fidelity.csv", index=False)
+
+    br = []
+    for name, sa, pa, kind in COMPARISONS:
+        for s in states:
+            d0 = abs(L0[sa, s]) - abs(L0[pa, s])
+            db = np.abs(LB[sa, s]) - np.abs(LB[pa, s])
+            lo, hi, n = ci(db)
+            blo, bhi = bc_ci(db, d0)
+            br.append({"comparison": name, "kind": kind, "scratch_arm": sa, "pretrained_arm": pa, "state": s,
+                       "role": CONTROLS.get(s, "rare state"), "informative": informative[s],
+                       "obs_thinned_state_cells_min": min(obsthin_tot[a, s] for a in ARMS),
+                       "ratio_scratch": r6(Sx.loc[(sa, s)].gen_over_obs),
+                       "ratio_pretrained": r6(Sx.loc[(pa, s)].gen_over_obs),
+                       "gen_state_scratch": int(A[sa, s]["gen_state"].sum()),
+                       "gen_state_pretrained": int(A[pa, s]["gen_state"].sum()),
+                       "abs_log2_scratch": r6(abs(L0[sa, s])), "abs_log2_pretrained": r6(abs(L0[pa, s])),
+                       "D": r6(d0), "D_ci_lo": r6(lo), "D_ci_hi": r6(hi), "p_boot": r6(p_boot(db)),
+                       "n_boot_valid": n, "verdict": verdict(lo, hi) if informative[s] else "uninformative",
+                       "D_bc_ci_lo": r6(blo), "D_bc_ci_hi": r6(bhi),
+                       "verdict_bc_sensitivity": verdict(blo, bhi) if informative[s] else "uninformative"})
+        d0 = np.mean([abs(L0[sa, s]) - abs(L0[pa, s]) for s in rare])
+        db = np.mean(np.vstack([np.abs(LB[sa, s]) - np.abs(LB[pa, s]) for s in rare]), axis=0)
+        lo, hi, n = ci(db)
+        blo, bhi = bc_ci(db, d0)
+        br.append({"comparison": name, "kind": kind, "scratch_arm": sa, "pretrained_arm": pa,
+                   "state": f"MEAN over {len(rare)} informative rare states", "role": "aggregate",
+                   "informative": True,
+                   "abs_log2_scratch": r6(np.mean([abs(L0[sa, s]) for s in rare])),
+                   "abs_log2_pretrained": r6(np.mean([abs(L0[pa, s]) for s in rare])),
+                   "D": r6(d0), "D_ci_lo": r6(lo), "D_ci_hi": r6(hi), "p_boot": r6(p_boot(db)), "n_boot_valid": n,
+                   "verdict": verdict(lo, hi), "D_bc_ci_lo": r6(blo), "D_bc_ci_hi": r6(bhi),
+                   "verdict_bc_sensitivity": verdict(blo, bhi)})
+    B = pd.DataFrame(br)
+    B.to_csv(OUT / "within_bootstrap.csv", index=False)
+    cr = []  # verdict counts per comparison
+    for name, sa, pa, kind in COMPARISONS:
+        t = B[(B.comparison == name) & (B.role != "aggregate")]
+        for label, m in [("rare states", t.role == "rare state"), ("controls", t.role != "rare state")]:
+            u = t[m]
+            row = {"comparison": name, "kind": kind, "scratch_arm": sa, "pretrained_arm": pa, "states": label,
+                   "n_states": len(u), "n_uninformative": int((u.verdict == "uninformative").sum())}
+            for col, tag in [("verdict", ""), ("verdict_bc_sensitivity", "bc_")]:
+                v = u[col]
+                row[f"{tag}pretrained_closer"] = int((v == "pretrained closer").sum())
+                row[f"{tag}scratch_closer"] = int((v == "scratch closer").sum())
+                row[f"{tag}not_significant"] = int((v == "not significant").sum())
+                row[f"{tag}pretrained_closer_states"] = "; ".join(u[v == "pretrained closer"].state)
+                row[f"{tag}scratch_closer_states"] = "; ".join(u[v == "scratch closer"].state)
+            row["point_D_positive"] = int((u.D > 0).sum())
+            row["point_D_negative"] = int((u.D < 0).sum())
+            cr.append(row)
+    pd.DataFrame(cr).to_csv(OUT / "within_bootstrap_counts.csv", index=False)
+
+    # ---------------- 3. contrast directions ---------------------------------------------------------------------
+    C = C.copy()
+    C["is_control"] = C.state.isin(list(CONTROLS))
+    w = C[C.arm.isin(TRAINED)].groupby(["state", "contrast"]).obs_diff
+    elig = pd.DataFrame({"min_abs_obs_diff_trained": w.apply(lambda v: v.abs().min()),
+                         "obs_sign_consistent_trained": w.apply(lambda v: np.sign(v).nunique() == 1)}).reset_index()
+    C = C.merge(elig, on=["state", "contrast"])
+    C["informative"] = C.state.map(informative)
+    C["eligible_common"] = (C.informative & (C.min_abs_obs_diff_trained >= CONTRAST_MIN)
+                            & C.obs_sign_consistent_trained)
+    C["eligible_own"] = C.informative & (C.obs_diff.abs() >= CONTRAST_MIN)
+    C["status"] = np.where(C.same_direction, "kept",
+                           np.where((C.gen_diff == 0) | C.gen_diff.isna(), "flat", "reversed"))
+    # strong reversal: generated difference of >= 0.5 percentage points in the wrong direction; weak: < 0.5 pp
+    # (i.e. essentially no generated disease difference rather than an opposite one)
+    C["reversal_strength"] = np.where(C.status != "reversed", "",
+                                      np.where(C.gen_diff.abs() >= CONTRAST_MIN, "strong", "weak"))
+    C["compression_gen_over_obs_diff"] = C.gen_diff / C.obs_diff
+    C["init"] = C.arm.map(lambda a: ARM_INFO[a][0])
+    C["pairs"] = C.arm.map(lambda a: ARM_INFO[a][1])
+    cols = ["arm", "init", "pairs", "state", "contrast", "is_control", "n_a", "n_b", "obs_a", "obs_b", "gen_a",
+            "gen_b", "obs_diff", "gen_diff", "compression_gen_over_obs_diff", "same_direction", "status",
+            "reversal_strength", "informative", "min_abs_obs_diff_trained", "eligible_common", "eligible_own"]
+    C[cols].to_csv(OUT / "within_contrast_directions.csv", index=False)
+    cnt = []
+    for a in ARMS:
+        for label, m in [("rare, common eligible set", C.eligible_common & ~C.is_control),
+                         ("rare, own eligible set", C.eligible_own & ~C.is_control),
+                         ("controls, own |obs_diff| >= 0.5", C.eligible_own & C.is_control)]:
+            t = C[(C.arm == a) & m]
+            cnt.append({"arm": a, "init": ARM_INFO[a][0], "pairs": ARM_INFO[a][1], "set": label, "n": len(t),
+                        "kept": int((t.status == "kept").sum()), "reversed": int((t.status == "reversed").sum()),
+                        "reversed_strong": int((t.reversal_strength == "strong").sum()),
+                        "reversed_weak": int((t.reversal_strength == "weak").sum()),
+                        "flat": int((t.status == "flat").sum()),
+                        "median_compression_kept": r6(t[t.status == "kept"].compression_gen_over_obs_diff.median())
+                        if (t.status == "kept").any() else None,
+                        "not_kept": "; ".join(f"{r.state} | {r.contrast} ({r.status} {r.reversal_strength}: "
+                                              f"gen {r.gen_diff:+.2f} vs obs {r.obs_diff:+.2f} pp)"
+                                              for r in t[t.status != "kept"].itertuples())})
+    pd.DataFrame(cnt).to_csv(OUT / "within_contrast_counts.csv", index=False)
+
+    # ---------------- 4. Spearman over donors --------------------------------------------------------------------
+    R0, RB = {}, {}
+    for a in ARMS:
+        for s in states:
+            R0[a, s] = spearman(A[a, s]["gen_pct"], A[a, s]["obsthin_pct"])
+            assert abs(R0[a, s] - Sx.loc[(a, s)].spearman_donors) < 1e-9 or (
+                np.isnan(R0[a, s]) and np.isnan(Sx.loc[(a, s)].spearman_donors)), (a, s)
+            RB[a, s] = boot_spearman(A[a, s], IDX)
+    sr = []
+    for name, sa, pa, kind in COMPARISONS:
+        for s in states:
+            diff = RB[pa, s] - RB[sa, s]
+            lo, hi, n = ci(diff)
+            slo, shi, _ = ci(RB[sa, s])
+            plo, phi, _ = ci(RB[pa, s])
+            sr.append({"comparison": name, "kind": kind, "scratch_arm": sa, "pretrained_arm": pa, "state": s,
+                       "role": CONTROLS.get(s, "rare state"), "informative": informative[s],
+                       "spearman_scratch": r6(R0[sa, s]), "scratch_ci_lo": r6(slo), "scratch_ci_hi": r6(shi),
+                       "spearman_pretrained": r6(R0[pa, s]), "pretrained_ci_lo": r6(plo),
+                       "pretrained_ci_hi": r6(phi),
+                       "diff_pretrained_minus_scratch": r6(R0[pa, s] - R0[sa, s]), "diff_ci_lo": r6(lo),
+                       "diff_ci_hi": r6(hi), "n_boot_valid": n,
+                       "verdict": verdict(lo, hi, "pretrained tracks donors better", "scratch tracks donors better")})
+        d0 = np.mean([R0[pa, s] - R0[sa, s] for s in rare])
+        db = np.nanmean(np.vstack([RB[pa, s] - RB[sa, s] for s in rare]), axis=0)
+        lo, hi, n = ci(db)
+        sr.append({"comparison": name, "kind": kind, "scratch_arm": sa, "pretrained_arm": pa,
+                   "state": f"MEAN over {len(rare)} informative rare states", "role": "aggregate",
+                   "informative": True,
+                   "spearman_scratch": r6(np.mean([R0[sa, s] for s in rare])),
+                   "spearman_pretrained": r6(np.mean([R0[pa, s] for s in rare])),
+                   "diff_pretrained_minus_scratch": r6(d0), "diff_ci_lo": r6(lo), "diff_ci_hi": r6(hi),
+                   "n_boot_valid": n,
+                   "verdict": verdict(lo, hi, "pretrained tracks donors better", "scratch tracks donors better")})
+    pd.DataFrame(sr).to_csv(OUT / "within_spearman.csv", index=False)
+
+    # ---------------- console digest -----------------------------------------------------------------------------
+    pd.set_option("display.width", 250)
+    pd.set_option("display.max_columns", 40)
+    pd.set_option("display.max_rows", 500)
+    print("donors", len(donors), dict(groups.value_counts()))
+    print("informative", informative)
+    print(B[["comparison", "state", "ratio_scratch", "ratio_pretrained", "D", "D_ci_lo", "D_ci_hi", "p_boot",
+             "verdict", "verdict_bc_sensitivity"]].round(3).to_string(index=False))
+    print(pd.read_csv(OUT / "within_bootstrap_counts.csv").drop(
+        columns=["scratch_arm", "pretrained_arm", "kind"]).to_string(index=False))
+    SR = pd.read_csv(OUT / "within_spearman.csv")
+    SR = SR[(SR.role == "rare state") & SR.informative]
+    print(SR.groupby("comparison").verdict.value_counts().unstack(fill_value=0).to_string())
+    print(SR.assign(pos=SR.diff_pretrained_minus_scratch > 0).groupby("comparison").pos.agg(["sum", "count"]))
+
+
+if __name__ == "__main__":
+    main()