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/confound_audit.py

@@ -0,0 +1,720 @@
+#!/usr/bin/env python3
+"""Confound audit: scratch vs pretrained rare-state generation, Ye 2026 sepsis held-out donors (CPU only; 2026-10-05).
+
+Read-only inputs (nothing existing is modified):
+  ../../work/sepsis/{fold0,loco}/<arm>.npz     per-cell marker extracts (markers, marker_symbols, lib_measured, donor,
+                                               aifi_l1, aifi_l2)
+  ../sepsis_{fold0,loco}_{summary,contrasts,per_donor}.csv
+  ../../tools/states.json; rule logic imported from ../../tools/screen.py (call_state, state_cols, parent_mask);
+  observed cells from ../../tools/sepsis_states.py observed() (same cells / labels / measured genes as the screen).
+Writes only confound_*.csv next to this script.  NaN / undefined -> 'null'.
+
+Sections
+  (0) reproduction of the screen's per-donor counts (same RNG sequence, seed 20261004) as a check of the inputs.
+  (a) generated depth per arm and parent; library ratio vs marker-gene depth ratio; the screen's 'thin' constant.
+  (b) generated vs observed composition; parent-pool sizes; parent-fraction vs within-parent decomposition per pair.
+  (c) depth-matching sensitivity for all marker states, three common references per setting (seed 20261005):
+        V1 'lib'    : thin every arm and the observed parent cells to the lowest generated parent median library
+                      (one constant per arm and state, as the screen does, but a common target for all arms);
+        V2 'msum'   : effective depth = sum over reference marker genes of the parent mean count, relative to the
+                      observed native parent (reference genes = the 73 extracted markers minus the state's own rule
+                      genes, observed parent mean >= 0.1); thin every arm and the observed to the lowest one;
+        V3 'mmed'   : as V2 with the median over reference genes of the per-gene mean ratio.
+      V0 = the screen as published (each arm's own observed thinning).  Donor bootstrap (B = 2000, seed 20261005) of
+      which arm of each scratch-vs-pretrained pair is closer to gen/obs = 1.
+  (d) donor spread / collapse: SD across donors of state %, composition, marker-level between-donor CV (sampling floor
+      removed), within-donor excess dispersion, and across-donor tracking of per-donor marker means.
+  (e) small-n contrasts: group sizes, generated state cells per group, leave-one-donor-out and donor-bootstrap
+      stability of same_direction (V0).
+  (f) positive / negative controls across arms and schemes.
+"""
+from __future__ import annotations
+
+import json
+import sys
+import time
+import warnings
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import pearsonr, spearmanr
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+sys.path.insert(0, str(PLAN / "tools"))
+from screen import call_state, parent_mask, state_cols  # noqa: E402
+import sepsis_states as ss  # noqa: E402
+
+OUT = PLAN / "out/scratch_vs_lora_20261005"
+SEED = 20261005
+NBOOT = 2000
+ORIG_THIN_SEED = 20261004
+FOCUS = ["MS1 monocyte (IL1R2+)", "C1Q-high monocyte (reference)", "Cycling monocyte (Ye 2026)",
+         "Plasmablast (markers)", "ISG-high T", "DN2 / ABC B"]
+CONTROLS = ["ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"]
+SETTINGS = {"fold0": ("work/sepsis/fold0", "out/sepsis_fold0_"), "loco": ("work/sepsis/loco", "out/sepsis_loco_")}
+ARM_CLASS = {
+    "fold0": {"zs__raw": "pretrained zero-shot", "lora_n5__raw": "pretrained LoRA (5 pairs)",
+              "scratch_n5__raw": "scratch (5 pairs)", "real_lora__raw": "pretrained LoRA (58 pairs)",
+              "real_full__raw": "pretrained full FT (58 pairs)", "scratch_full__raw": "scratch (58 pairs, 100k cap)",
+              "lora_recipe__raw": "pretrained LoRA + recipes (58 pairs)",
+              "scratch_recipe__raw": "scratch + recipes (58 pairs)"},
+    "loco": {"zs__raw": "pretrained zero-shot", "xcalL_K1000": "pretrained zero-shot + cross-cohort calibration",
+             "locoL_lora16sat_s26750_K1000": "pretrained LoRA r16 (cross-cohort)",
+             "locoL_lora64sat_s59000_K1000": "pretrained LoRA r64 (cross-cohort)",
+             "locoL_fullsat_s20000_K1000": "pretrained full FT 20k (cross-cohort)",
+             "locoL_fullsat_s108500_K1000": "pretrained full FT 108.5k saturated (cross-cohort)",
+             "locoL_scratchsat_s50000_K1000": "scratch 50k (cross-cohort)",
+             "locoL_scratchsat_s100000_K1000": "scratch 100k (cross-cohort)",
+             "locoL_scratchsat_s150000_K1000": "scratch 150k (cross-cohort)",
+             "locoL_scratchsat_s162000_K1000": "scratch 162k final (cross-cohort)",
+             "lora_n5__raw": "own-cohort pretrained LoRA (5 pairs, cross-fitted)",
+             "real_lora__raw": "own-cohort pretrained LoRA (~58 pairs, cross-fitted)"},
+}
+PAIRS = {
+    "fold0": [("n5", "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"),
+              ("58 pairs + recipes", "scratch_recipe__raw", "lora_recipe__raw")],
+    "loco": [("final scratch vs LoRA r16", "locoL_scratchsat_s162000_K1000", "locoL_lora16sat_s26750_K1000"),
+             ("final scratch vs LoRA r64", "locoL_scratchsat_s162000_K1000", "locoL_lora64sat_s59000_K1000"),
+             ("final scratch vs full FT 108.5k", "locoL_scratchsat_s162000_K1000", "locoL_fullsat_s108500_K1000"),
+             ("final scratch vs full FT 20k", "locoL_scratchsat_s162000_K1000", "locoL_fullsat_s20000_K1000")],
+}
+L1_TYPES = ["Monocyte", "T cell", "B cell", "NK cell"]
+REP_STATE = {"Monocyte": "MS1 monocyte (IL1R2+)", "T cell": "ISG-high T", "B cell": "DN2 / ABC B",
+             "ALL": "Plasmablast (markers)"}
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+
+
+def is_scratch(arm: str) -> bool:
+    return "scratch" in arm
+
+
+def safe_spearman(x: np.ndarray, y: np.ndarray) -> float:
+    if len(x) < 3 or np.nanstd(x) == 0 or np.nanstd(y) == 0:
+        return np.nan
+    return float(spearmanr(x, y).correlation)
+
+
+def safe_pearson(x: np.ndarray, y: np.ndarray) -> float:
+    if len(x) < 3 or np.nanstd(x) == 0 or np.nanstd(y) == 0:
+        return np.nan
+    return float(pearsonr(x, y)[0])
+
+
+def abs_log2(r: float) -> float:
+    """|log2 gen/obs|; null for a complete miss (r = 0) or undefined r."""
+    return float(abs(np.log2(r))) if (r is not None and np.isfinite(r) and r > 0) else np.nan
+
+
+def rule_parts(st: dict, syms: list[str]):
+    sym2col = {s: i for i, s in enumerate(syms)}
+    ident = {s: s for s in syms}
+    _, pcols, req, exc = state_cols(st, ident, sym2col)
+    cols = pcols + [x for r in req for x in r] + exc
+    rule_syms = set(st.get("genes", [])) | {x for g in st.get("require_any", []) for x in g} | set(st.get("exclude", []))
+    return cols, len(pcols), req, exc, rule_syms
+
+
+def write(df: pd.DataFrame, name: str) -> None:
+    df = df.replace([np.inf, -np.inf], np.nan)
+    df.to_csv(OUT / f"confound_{name}.csv", index=False, na_rep="null", float_format="%.6g")
+    print(f"wrote confound_{name}.csv ({len(df)} rows)", flush=True)
+
+
+# ----------------------------------------------------------------------------------------------------------- load
+t0 = time.time()
+STATES = json.loads((PLAN / "tools/states.json").read_text())
+SBY = {s["name"]: s for s in STATES}
+MARKER_STATES = [s["name"] for s in STATES if s["kind"] == "markers"]
+summ = {k: pd.read_csv(PLAN / f"{v[1]}summary.csv") for k, v in SETTINGS.items()}
+perd = {k: pd.read_csv(PLAN / f"{v[1]}per_donor.csv") for k, v in SETTINGS.items()}
+cons = {k: pd.read_csv(PLAN / f"{v[1]}contrasts.csv") for k, v in SETTINGS.items()}
+ARMS = {k: list(dict.fromkeys(summ[k].arm)) for k in SETTINGS}
+GEN = {k: {a: dict(np.load(PLAN / SETTINGS[k][0] / f"{a}.npz", allow_pickle=False)) for a in ARMS[k]}
+       for k in SETTINGS}
+SYMS = list(GEN["loco"]["zs__raw"]["marker_symbols"].astype(str))
+DONORS = {k: sorted(set(GEN[k][ARMS[k][0]]["donor"])) for k in SETTINGS}
+for k in SETTINGS:
+    for a in ARMS[k]:
+        g = GEN[k][a]
+        if list(g["marker_symbols"].astype(str)) != SYMS or sorted(set(g["donor"])) != DONORS[k]:
+            raise SystemExit(f"{k}/{a}: marker columns or donors differ")
+ob_all = ss.observed(STATES, DONORS["loco"])
+if list(ob_all["marker_symbols"]) != SYMS:
+    raise SystemExit("observed marker columns differ")
+GROUPS = ob_all["groups"]
+OBS = {}
+for k in SETTINGS:
+    m = np.isin(ob_all["donor"], DONORS[k])
+    OBS[k] = {"markers": ob_all["markers"][m], "lib": ob_all["lib"][m], "donor": ob_all["donor"][m],
+              "lab": ob_all["lab"][m].reset_index(drop=True)}
+DIDX = {}  # donor index per cell, per setting, for bincount
+for k in SETTINGS:
+    pos = {d: i for i, d in enumerate(DONORS[k])}
+    DIDX[(k, "OBS")] = np.asarray([pos[d] for d in OBS[k]["donor"]])
+    for a in ARMS[k]:
+        DIDX[(k, a)] = np.asarray([pos[d] for d in GEN[k][a]["donor"]])
+GRP = {k: np.asarray([GROUPS.get(d) for d in DONORS[k]]) for k in SETTINGS}
+print(f"loaded in {time.time() - t0:.1f}s; observed cells {len(ob_all['lib']):,}", flush=True)
+
+
+def lab_df(k: str, a: str) -> pd.DataFrame:
+    if a == "OBS":
+        return OBS[k]["lab"]
+    return pd.DataFrame({"aifi_l1": GEN[k][a]["aifi_l1"], "aifi_l2": GEN[k][a]["aifi_l2"]})
+
+
+def per_donor(k: str, a: str, mask: np.ndarray) -> np.ndarray:
+    return np.bincount(DIDX[(k, a)][mask], minlength=len(DONORS[k]))
+
+
+# ------------------------------------------------------------------------------------ (0) reproduction of the screen
+rows = []
+for k in SETTINGS:
+    rng = np.random.default_rng(ORIG_THIN_SEED)
+    ob = OBS[k]
+    rep = []
+    for a in ARMS[k]:
+        g = GEN[k][a]
+        lg = lab_df(k, a)
+        for st in STATES:
+            po, pg = parent_mask(ob["lab"], st["parent"]), parent_mask(lg, st["parent"])
+            if st["kind"] == "label":
+                ho = ob["lab"].aifi_l2.isin(st["labels"]).to_numpy() & po
+                hg = lg.aifi_l2.isin(st["labels"]).to_numpy() & pg
+                ht = ho
+            else:
+                cols, npos, req, exc, _ = rule_parts(st, SYMS)
+                thin = min(1.0, float(np.median(g["lib_measured"][pg])) / float(np.median(ob["lib"][po])))
+                co = ob["markers"][:, cols].astype(np.int64)
+                ho = call_state(co, st, npos, req, exc) & po
+                ct = rng.binomial(co, thin) if thin < 1.0 else co
+                ht = call_state(ct, st, npos, req, exc) & po
+                hg = call_state(g["markers"][:, cols], st, npos, req, exc) & pg
+            rep.append(pd.DataFrame({"arm": a, "state": st["name"], "donor": DONORS[k],
+                                     "obs_parent": per_donor(k, "OBS", po), "obs_state": per_donor(k, "OBS", ho),
+                                     "obsthin_state": per_donor(k, "OBS", ht), "gen_parent": per_donor(k, a, pg),
+                                     "gen_state": per_donor(k, a, hg)}))
+    rep = pd.concat(rep)
+    mrg = perd[k].merge(rep, on=["arm", "state", "donor"], suffixes=("", "_re"), how="outer", indicator=True)
+    row = {"setting": k, "rows_csv": len(perd[k]), "rows_reproduced": len(rep),
+           "rows_unmatched": int((mrg["_merge"] != "both").sum())}
+    for c in ["obs_parent", "obs_state", "obsthin_state", "gen_parent", "gen_state"]:
+        row[f"mismatch_{c}"] = int((mrg[c] != mrg[f"{c}_re"]).sum())
+    rows.append(row)
+VALID = pd.DataFrame(rows)
+write(VALID, "validation")
+print(VALID.to_string(index=False), flush=True)
+
+# --------------------------------------------------------------------------------------------------------- (a) depth
+rows = []
+for k in SETTINGS:
+    ob = OBS[k]
+    for P in ["ALL"] + L1_TYPES:
+        po = parent_mask(ob["lab"], [P])
+        mo = ob["markers"][po].mean(0)
+        ref = mo >= 0.1
+        olib = ob["lib"][po]
+        base = {"setting": k, "parent": P, "n_ref_genes": int(ref.sum())}
+        rows.append({**base, "arm": "OBSERVED (native)", "arm_class": "observed", "n_cells": int(po.sum()),
+                     "lib_q10": np.quantile(olib, .1), "lib_q25": np.quantile(olib, .25), "lib_median": np.median(olib),
+                     "lib_q75": np.quantile(olib, .75), "lib_q90": np.quantile(olib, .9),
+                     "marker_share_median": float(np.median(ob["markers"][po].sum(1) / np.maximum(olib, 1))),
+                     "lib_ratio_vs_obs": 1.0, "marker_sum_ratio_vs_obs": 1.0, "marker_median_ratio_vs_obs": 1.0})
+        for a in ARMS[k]:
+            g = GEN[k][a]
+            pg = parent_mask(lab_df(k, a), [P])
+            glib = g["lib_measured"][pg]
+            mg = g["markers"][pg].mean(0)
+            r_sum = float(mg[ref].sum() / mo[ref].sum())
+            r_med = float(np.median(mg[ref] / mo[ref]))
+            thin = np.nan
+            if P in REP_STATE:
+                s = summ[k][(summ[k].arm == a) & (summ[k].state == REP_STATE[P])]
+                thin = float(s.thin.iloc[0])
+            rows.append({**base, "arm": a, "arm_class": ARM_CLASS[k][a], "n_cells": int(pg.sum()),
+                         "lib_q10": np.quantile(glib, .1), "lib_q25": np.quantile(glib, .25),
+                         "lib_median": np.median(glib), "lib_q75": np.quantile(glib, .75),
+                         "lib_q90": np.quantile(glib, .9),
+                         "marker_share_median": float(np.median(g["markers"][pg].sum(1) / np.maximum(glib, 1))),
+                         "lib_ratio_vs_obs": float(np.median(glib) / np.median(olib)),
+                         "marker_sum_ratio_vs_obs": r_sum, "marker_median_ratio_vs_obs": r_med,
+                         "screen_thin": thin,
+                         # generated marker-gene depth relative to the observed reference the screen compared it with
+                         "marker_depth_vs_screen_reference": r_sum / thin if np.isfinite(thin) else np.nan})
+DEPTH = pd.DataFrame(rows)
+write(DEPTH, "depth")
+
+# ------------------------------------------------------------------------------------------- (b) composition, pools
+rows = []
+for k in SETTINGS:
+    for a in ["OBS"] + ARMS[k]:
+        lab = lab_df(k, a)
+        n_d = per_donor(k, a, np.ones(len(lab), bool)).astype(float)
+        cats = {t: (lab.aifi_l1 == t).to_numpy() for t in L1_TYPES}
+        cats["Plasma cell (L2)"] = (lab.aifi_l2 == "Plasma cell").to_numpy()
+        cats["other L1"] = ~lab.aifi_l1.isin(L1_TYPES).to_numpy()
+        for t, msk in cats.items():
+            c = per_donor(k, a, msk)
+            frac = 100 * c / np.where(n_d > 0, n_d, np.nan)
+            rows.append({"setting": k, "arm": "OBSERVED" if a == "OBS" else a,
+                         "arm_class": "observed" if a == "OBS" else ARM_CLASS[k][a], "cell_type": t,
+                         "n_cells": int(c.sum()), "pooled_pct": 100 * c.sum() / n_d.sum(),
+                         "donor_mean_pct": float(np.nanmean(frac)), "donor_sd_pct": float(np.nanstd(frac, ddof=1)),
+                         "donor_min_n": int(c.min()), "donor_median_n": float(np.median(c)),
+                         "n_donors_lt20": int((c < 20).sum()), "n_donors_zero": int((c == 0).sum())})
+COMP = pd.DataFrame(rows)
+obs_ref = COMP[COMP.arm == "OBSERVED"].set_index(["setting", "cell_type"])
+COMP["gen_over_obs_pooled"] = [r.pooled_pct / obs_ref.loc[(r.setting, r.cell_type), "pooled_pct"]
+                               for r in COMP.itertuples()]
+COMP["gen_over_obs_donor_mean"] = [r.donor_mean_pct / obs_ref.loc[(r.setting, r.cell_type), "donor_mean_pct"]
+                                   for r in COMP.itertuples()]
+write(COMP, "composition")
+
+# cross-check: observed composition implied by obs_parent of the per-donor CSV equals the label-derived one
+chk = []
+for k in SETTINGS:
+    P = perd[k][perd[k].arm == ARMS[k][0]].set_index(["state", "donor"])
+    tot = P.loc["Plasmablast (label)"].obs_parent
+    for t, st in [("Monocyte", "C1Q-high monocyte (reference)"), ("T cell", "ISG-high T"), ("B cell", "DN2 / ABC B")]:
+        v = 100 * P.loc[st].obs_parent.sum() / tot.sum()
+        lab_v = obs_ref.loc[(k, t), "pooled_pct"]
+        chk.append({"setting": k, "cell_type": t, "pct_from_per_donor_csv": v, "pct_from_labels": lab_v})
+    v = 100 * P.loc["Plasmablast (label)"].obs_state.sum() / tot.sum()
+    chk.append({"setting": k, "cell_type": "Plasma cell (L2)", "pct_from_per_donor_csv": v,
+                "pct_from_labels": obs_ref.loc[(k, "Plasma cell (L2)"), "pooled_pct"]})
+print(pd.DataFrame(chk).round(3).to_string(index=False), flush=True)
+
+rows = []
+for k in SETTINGS:
+    for (a, s), t in perd[k].groupby(["arm", "state"], sort=False):
+        rows.append({"setting": k, "arm": a, "arm_class": ARM_CLASS[k][a], "state": s,
+                     "parent": "+".join(SBY[s]["parent"]),
+                     "gen_parent_total": int(t.gen_parent.sum()), "gen_parent_donor_min": int(t.gen_parent.min()),
+                     "gen_parent_donor_median": float(t.gen_parent.median()),
+                     "n_donors_gen_parent_lt20": int((t.gen_parent < 20).sum()),
+                     "n_donors_gen_parent_zero": int((t.gen_parent == 0).sum()),
+                     "obs_parent_total": int(t.obs_parent.sum()), "obs_parent_donor_min": int(t.obs_parent.min()),
+                     "obs_parent_donor_median": float(t.obs_parent.median()),
+                     "gen_parent_pct_of_cells": 100 * t.gen_parent.sum() / (1500 * len(t)),
+                     "gen_state_total": int(t.gen_state.sum()), "obsthin_state_total": int(t.obsthin_state.sum()),
+                     "n_donors_gen_state_zero": int((t.gen_state == 0).sum())})
+POOLS = pd.DataFrame(rows)
+tot_obs = {k: perd[k][(perd[k].arm == ARMS[k][0]) & (perd[k].state == "Plasmablast (label)")].obs_parent.sum()
+           for k in SETTINGS}
+POOLS["obs_parent_pct_of_cells"] = [100 * r.obs_parent_total / tot_obs[r.setting] for r in POOLS.itertuples()]
+POOLS["parent_gen_over_obs"] = POOLS.gen_parent_pct_of_cells / POOLS.obs_parent_pct_of_cells
+write(POOLS, "parent_pools")
+
+S_IDX = {k: summ[k].set_index(["arm", "state"]) for k in SETTINGS}
+rows = []
+for k in SETTINGS:
+    for lab_, sa, pa in PAIRS[k]:
+        for s in FOCUS + CONTROLS + ["Plasmablast (label)", "Proliferating T (label)", "Cycling T/NK",
+                                    "Granulocyte-like (LDG)", "HSPC"]:
+            ts = perd[k][(perd[k].arm == sa) & (perd[k].state == s)]
+            tp = perd[k][(perd[k].arm == pa) & (perd[k].state == s)]
+            n_s, n_p = 1500 * len(ts), 1500 * len(tp)
+            pf_s, pf_p = ts.gen_parent.sum() / n_s, tp.gen_parent.sum() / n_p
+            w_s = ts.gen_state.sum() / max(ts.gen_parent.sum(), 1)
+            w_p = tp.gen_state.sum() / max(tp.gen_parent.sum(), 1)
+            l2 = lambda x, y: float(np.log2(x / y)) if (x > 0 and y > 0) else np.nan  # noqa: E731
+            rows.append({"setting": k, "pair": lab_, "scratch_arm": sa, "pretrained_arm": pa, "state": s,
+                         "parent": "+".join(SBY[s]["parent"]),
+                         "scratch_parent_pct": 100 * pf_s, "pretrained_parent_pct": 100 * pf_p,
+                         "scratch_within_parent_pct": 100 * w_s, "pretrained_within_parent_pct": 100 * w_p,
+                         "scratch_state_per_1000_cells": 1000 * ts.gen_state.sum() / n_s,
+                         "pretrained_state_per_1000_cells": 1000 * tp.gen_state.sum() / n_p,
+                         "log2_parent_frac_scratch_over_pretrained": l2(pf_s, pf_p),
+                         "log2_within_parent_scratch_over_pretrained": l2(w_s, w_p),
+                         "log2_state_per_cell_scratch_over_pretrained": l2(ts.gen_state.sum() / n_s,
+                                                                          tp.gen_state.sum() / n_p),
+                         "scratch_gen_over_obs_screen": float(S_IDX[k].loc[(sa, s), "gen_over_obs"]),
+                         "pretrained_gen_over_obs_screen": float(S_IDX[k].loc[(pa, s), "gen_over_obs"]),
+                         "scratch_gen_state_total": int(ts.gen_state.sum()),
+                         "pretrained_gen_state_total": int(tp.gen_state.sum())})
+DECOMP = pd.DataFrame(rows)
+DECOMP["share_of_log2_difference_from_parent_pool"] = (
+    DECOMP.log2_parent_frac_scratch_over_pretrained / DECOMP.log2_state_per_cell_scratch_over_pretrained)
+write(DECOMP, "decomposition")
+
+
+# ---------------------------------------------------------------------------------- (c) depth-matching sensitivity
+def metrics(k: str, gs, gp, os_, op) -> dict:
+    rg = 100 * gs.sum() / max(gp.sum(), 1)
+    ro = 100 * os_.sum() / max(op.sum(), 1)
+    ratio = rg / ro if ro > 0 else np.nan
+    gpct = np.where(gp > 0, 100 * gs / np.maximum(gp, 1), np.nan)
+    opct = np.where(op > 0, 100 * os_ / np.maximum(op, 1), np.nan)
+    ok = ~np.isnan(gpct) & ~np.isnan(opct)
+    out = {"gen_state": int(gs.sum()), "gen_parent": int(gp.sum()), "gen_pct": rg,
+           "obs_state": int(os_.sum()), "obs_parent": int(op.sum()), "obs_pct": ro, "gen_over_obs": ratio,
+           "abs_log2": abs_log2(ratio), "complete_miss": bool(gs.sum() == 0),
+           "spearman_donors": safe_spearman(gpct[ok], opct[ok]),
+           "gen_over_obs_donor_mean": (np.nanmean(gpct) / np.nanmean(opct)) if np.nanmean(opct) > 0 else np.nan}
+    for name, A, Bg in ss.CONTRASTS:
+        ia, ib = np.isin(GRP[k], A), np.isin(GRP[k], Bg)
+        od = np.nanmean(opct[ia]) - np.nanmean(opct[ib])
+        gd = np.nanmean(gpct[ia]) - np.nanmean(gpct[ib])
+        key = {"adult sepsis vs adult HC": "adult", "paediatric sepsis vs paediatric HC": "ped",
+               "all sepsis vs all controls": "all"}[name]
+        out[f"obs_diff_{key}"], out[f"gen_diff_{key}"] = od, gd
+        out[f"same_direction_{key}"] = (bool(np.sign(od) == np.sign(gd))
+                                        if np.isfinite(od) and np.isfinite(gd) else None)
+    return out
+
+
+rng_thin = np.random.default_rng(SEED)
+PDON = {}       # (setting, scheme, state, arm) -> (gen_state, gen_parent, obs_state, obs_parent) per donor
+rows, trows = [], []
+for k in SETTINGS:
+    ob = OBS[k]
+    for st in STATES:
+        s = st["name"]
+        # V0: the screen as published (per-donor CSV; each arm has its own observed thinning)
+        for a in ARMS[k]:
+            t = perd[k][(perd[k].arm == a) & (perd[k].state == s)].set_index("donor").loc[DONORS[k]]
+            v = (t.gen_state.to_numpy(), t.gen_parent.to_numpy(), t.obsthin_state.to_numpy(), t.obs_parent.to_numpy())
+            PDON[(k, "V0_screen", s, a)] = v
+            rows.append({"setting": k, "scheme": "V0_screen", "state": s, "arm": a, "arm_class": ARM_CLASS[k][a],
+                         "p_gen": 1.0, "p_obs": float(S_IDX[k].loc[(a, s), "thin"]), **metrics(k, *v)})
+        if st["kind"] != "markers":
+            continue
+        cols, npos, req, exc, rule_syms = rule_parts(st, SYMS)
+        po = parent_mask(ob["lab"], st["parent"])
+        mo = ob["markers"][po].mean(0)
+        ref = np.asarray([(sym not in rule_syms) and mo[j] >= 0.1 for j, sym in enumerate(SYMS)])
+        olib_med = float(np.median(ob["lib"][po]))
+        pg_ = {a: parent_mask(lab_df(k, a), st["parent"]) for a in ARMS[k]}
+        glib_med = {a: float(np.median(GEN[k][a]["lib_measured"][pg_[a]])) for a in ARMS[k]}
+        rsum, rmed = {}, {}
+        for a in ARMS[k]:
+            mg = GEN[k][a]["markers"][pg_[a]].mean(0)
+            rsum[a] = float(mg[ref].sum() / mo[ref].sum())
+            rmed[a] = float(np.median(mg[ref] / mo[ref]))
+        if min(rsum.values()) <= 0 or min(rmed.values()) <= 0 or min(glib_med.values()) <= 0:
+            raise SystemExit(f"{k}/{s}: zero effective depth in some arm; schemes undefined")
+        targets = {
+            "V1_lib": (min(min(glib_med.values()), olib_med),
+                       {a: min(1.0, min(min(glib_med.values()), olib_med) / glib_med[a]) for a in ARMS[k]},
+                       min(1.0, min(min(glib_med.values()), olib_med) / olib_med)),
+            "V2_msum": (min(1.0, min(rsum.values())), {a: min(1.0, min(1.0, min(rsum.values())) / rsum[a])
+                                                       for a in ARMS[k]}, min(1.0, min(rsum.values()))),
+            "V3_mmed": (min(1.0, min(rmed.values())), {a: min(1.0, min(1.0, min(rmed.values())) / rmed[a])
+                                                       for a in ARMS[k]}, min(1.0, min(rmed.values()))),
+        }
+        co = ob["markers"][po][:, cols].astype(np.int64)
+        for sch, (target, pga, pob) in targets.items():
+            trows.append({"setting": k, "state": s, "scheme": sch, "target": target, "p_obs": pob,
+                          "reference_genes": ";".join(np.asarray(SYMS)[ref]) if sch != "V1_lib" else "",
+                          "lowest_arm": (min(glib_med, key=glib_med.get) if sch == "V1_lib" else
+                                         min(rsum, key=rsum.get) if sch == "V2_msum" else min(rmed, key=rmed.get)),
+                          **{f"p_gen[{a}]": pga[a] for a in ARMS[k]}})
+            ct = rng_thin.binomial(co, pob) if pob < 1.0 else co
+            ho = np.zeros(len(po), bool)
+            ho[po] = call_state(ct, st, npos, req, exc)
+            os_, op = per_donor(k, "OBS", ho), per_donor(k, "OBS", po)
+            for a in ARMS[k]:
+                cg = GEN[k][a]["markers"][pg_[a]][:, cols].astype(np.int64)
+                cgt = rng_thin.binomial(cg, pga[a]) if pga[a] < 1.0 else cg
+                hg = np.zeros(len(pg_[a]), bool)
+                hg[pg_[a]] = call_state(cgt, st, npos, req, exc)
+                v = (per_donor(k, a, hg), per_donor(k, a, pg_[a]), os_, op)
+                PDON[(k, sch, s, a)] = v
+                rows.append({"setting": k, "scheme": sch, "state": s, "arm": a, "arm_class": ARM_CLASS[k][a],
+                             "p_gen": pga[a], "p_obs": pob, **metrics(k, *v)})
+    print(f"{k}: depth-matching done ({time.time() - t0:.1f}s)", flush=True)
+DM = pd.DataFrame(rows)
+write(DM, "depthmatch")
+write(pd.DataFrame(trows), "depthmatch_targets")
+
+# per-donor counts of the schemes for the focus states and controls (traceability)
+rows = []
+for (k, sch, s, a), (gs, gp, os_, op) in PDON.items():
+    if s in FOCUS + CONTROLS and sch != "V0_screen":
+        rows.append(pd.DataFrame({"setting": k, "scheme": sch, "state": s, "arm": a, "donor": DONORS[k],
+                                  "group": GRP[k], "gen_state": gs, "gen_parent": gp, "obs_state": os_,
+                                  "obs_parent": op}))
+write(pd.concat(rows), "depthmatch_per_donor")
+
+# pairs: which arm is closer to gen/obs = 1, per scheme, with a donor bootstrap
+rng_boot = np.random.default_rng(SEED)
+
+
+def boot_abslog2(idx, gs, gp, os_, op):
+    rg = gs[idx].sum(1) / np.maximum(gp[idx].sum(1), 1)
+    ro = os_[idx].sum(1) / np.maximum(op[idx].sum(1), 1)
+    r = np.where(ro > 0, rg / np.where(ro > 0, ro, 1), np.nan)
+    a = np.where(r > 0, np.abs(np.log2(np.where(r > 0, r, 1))), np.inf)  # complete miss -> inf (worst)
+    return np.where(np.isnan(r), np.nan, a)
+
+
+rows = []
+DMI = DM.set_index(["setting", "scheme", "state", "arm"])
+for k in SETTINGS:
+    nd = len(DONORS[k])
+    for sch in ["V0_screen", "V1_lib", "V2_msum", "V3_mmed"]:
+        for s in MARKER_STATES + ["Plasmablast (label)", "Proliferating T (label)"]:
+            if (k, sch, s, ARMS[k][0]) not in PDON:
+                continue
+            for lab_, sa, pa in PAIRS[k]:
+                rs, rp = DMI.loc[(k, sch, s, sa)], DMI.loc[(k, sch, s, pa)]
+                as_ = rs.abs_log2 if not rs.complete_miss else np.inf
+                ap_ = rp.abs_log2 if not rp.complete_miss else np.inf
+                closer = ("undefined" if (np.isnan(as_) or np.isnan(ap_)) else
+                          "scratch" if as_ < ap_ else "pretrained" if ap_ < as_ else "tie")
+                idx = rng_boot.integers(0, nd, size=(NBOOT, nd))
+                bs = boot_abslog2(idx, *PDON[(k, sch, s, sa)])
+                bp = boot_abslog2(idx, *PDON[(k, sch, s, pa)])
+                ok = ~np.isnan(bs) & ~np.isnan(bp)
+                p_closer = float(np.mean(bs[ok] < bp[ok]) + 0.5 * np.mean(bs[ok] == bp[ok])) if ok.any() else np.nan
+                gs_s, gp_s = PDON[(k, sch, s, sa)][:2]
+                gs_p, gp_p = PDON[(k, sch, s, pa)][:2]
+                rate_s = gs_s[idx].sum(1) / np.maximum(gp_s[idx].sum(1), 1)
+                rate_p = gs_p[idx].sum(1) / np.maximum(gp_p[idx].sum(1), 1)
+                rows.append({"setting": k, "scheme": sch, "state": s, "pair": lab_, "scratch_arm": sa,
+                             "pretrained_arm": pa,
+                             "scratch_gen_over_obs": rs.gen_over_obs, "pretrained_gen_over_obs": rp.gen_over_obs,
+                             "scratch_abs_log2": rs.abs_log2, "pretrained_abs_log2": rp.abs_log2,
+                             "scratch_complete_miss": rs.complete_miss, "pretrained_complete_miss": rp.complete_miss,
+                             "closer_to_1": closer, "boot_p_scratch_closer": p_closer,
+                             "scratch_gen_pct": rs.gen_pct, "pretrained_gen_pct": rp.gen_pct,
+                             "boot_p_scratch_gen_pct_higher": float(np.mean(rate_s > rate_p) +
+                                                                    0.5 * np.mean(rate_s == rate_p)),
+                             "scratch_spearman": rs.spearman_donors, "pretrained_spearman": rp.spearman_donors,
+                             "scratch_gen_state": rs.gen_state, "pretrained_gen_state": rp.gen_state,
+                             "obs_state_scratch_ref": rs.obs_state, "obs_state_pretrained_ref": rp.obs_state})
+PAIRDF = pd.DataFrame(rows)
+v0 = PAIRDF[PAIRDF.scheme == "V0_screen"].set_index(["setting", "state", "pair"]).closer_to_1
+PAIRDF["closer_to_1_V0"] = [v0.get((r.setting, r.state, r.pair)) for r in PAIRDF.itertuples()]
+PAIRDF["ordering_changed_vs_V0"] = [(r.closer_to_1 != r.closer_to_1_V0) if r.scheme != "V0_screen" else False
+                                    for r in PAIRDF.itertuples()]
+PAIRDF["in_focus"] = PAIRDF.state.isin(FOCUS)
+write(PAIRDF, "depthmatch_pairs")
+
+# ------------------------------------------------------------------------------------------- (d) spread / collapse
+rows = []
+for (k, sch, s, a), (gs, gp, os_, op) in PDON.items():
+    if sch not in ("V0_screen", "V2_msum"):
+        continue
+    ok = (gp >= 20) & (op >= 20)
+    gpct, opct = 100 * gs[ok] / gp[ok], 100 * os_[ok] / op[ok]
+    sdg, sdo = (float(np.std(gpct, ddof=1)), float(np.std(opct, ddof=1))) if ok.sum() > 2 else (np.nan, np.nan)
+    rows.append({"setting": k, "scheme": sch, "state": s, "arm": a, "arm_class": ARM_CLASS[k][a],
+                 "n_donors_parent_ge20": int(ok.sum()), "sd_gen_pct": sdg, "sd_obs_pct": sdo,
+                 "sd_ratio_gen_over_obs": sdg / sdo if (sdo and np.isfinite(sdo) and sdo > 0) else np.nan,
+                 "iqr_gen_pct": float(np.subtract(*np.percentile(gpct, [75, 25]))) if ok.sum() > 2 else np.nan,
+                 "iqr_obs_pct": float(np.subtract(*np.percentile(opct, [75, 25]))) if ok.sum() > 2 else np.nan,
+                 "mean_gen_pct": float(np.mean(gpct)) if ok.any() else np.nan,
+                 "mean_obs_pct": float(np.mean(opct)) if ok.any() else np.nan,
+                 "n_donors_gen_state_zero": int((gs[ok] == 0).sum()),
+                 "spearman_donors": safe_spearman(gpct, opct)})
+write(pd.DataFrame(rows), "collapse_states")
+
+rows = []
+for k in SETTINGS:
+    nd = len(DONORS[k])
+    lab_o = lab_df(k, "OBS")
+    n_o = per_donor(k, "OBS", np.ones(len(lab_o), bool))
+    fo = {t: 100 * per_donor(k, "OBS", (lab_o.aifi_l1 == t).to_numpy()) / n_o for t in L1_TYPES}
+    fo["Plasma cell (L2)"] = 100 * per_donor(k, "OBS", (lab_o.aifi_l2 == "Plasma cell").to_numpy()) / n_o
+    for a in ARMS[k]:
+        lab = lab_df(k, a)
+        n_g = per_donor(k, a, np.ones(len(lab), bool))
+        r_all = []
+        for t in L1_TYPES + ["Plasma cell (L2)"]:
+            msk = (lab.aifi_l2 == "Plasma cell").to_numpy() if t == "Plasma cell (L2)" else (lab.aifi_l1 == t).to_numpy()
+            fg = 100 * per_donor(k, a, msk) / n_g
+            sdg, sdo = float(np.std(fg, ddof=1)), float(np.std(fo[t], ddof=1))
+            r = safe_pearson(fg, fo[t])
+            r_all.append(r)
+            rows.append({"setting": k, "arm": a, "arm_class": ARM_CLASS[k][a], "cell_type": t,
+                         "sd_gen_pct": sdg, "sd_obs_pct": sdo, "sd_ratio_gen_over_obs": sdg / sdo if sdo > 0 else np.nan,
+                         "pearson_donors": r, "spearman_donors": safe_spearman(fg, fo[t]),
+                         "mean_gen_pct": float(np.mean(fg)), "mean_obs_pct": float(np.mean(fo[t]))})
+        rows.append({"setting": k, "arm": a, "arm_class": ARM_CLASS[k][a], "cell_type": "MEAN over 4 L1 types",
+                     "pearson_donors": float(np.nanmean(r_all[:4]))})
+write(pd.DataFrame(rows), "collapse_composition")
+
+
+def gene_stats(M: np.ndarray, didx: np.ndarray, nd: int, min_cells: int = 20):
+    """Per donor (>= min_cells parent cells): mean, variance and n of each gene's counts."""
+    n = np.bincount(didx, minlength=nd).astype(float)
+    s1 = np.stack([np.bincount(didx, weights=M[:, j], minlength=nd) for j in range(M.shape[1])], 1)
+    s2 = np.stack([np.bincount(didx, weights=M[:, j].astype(float) ** 2, minlength=nd) for j in range(M.shape[1])], 1)
+    keep = n >= min_cells
+    nn = np.where(keep, n, np.nan)[:, None]
+    mu = s1 / nn
+    var = (s2 - nn * mu ** 2) / (nn - 1)
+    return mu, var, n, keep
+
+
+rows, grows = [], []
+for k in SETTINGS:
+    nd = len(DONORS[k])
+    ob = OBS[k]
+    for P in L1_TYPES:
+        po = parent_mask(ob["lab"], [P])
+        mo_all = ob["markers"][po].mean(0)
+        genes = np.flatnonzero(mo_all >= 0.2)
+        mu_o, var_o, n_o, keep_o = gene_stats(ob["markers"][po][:, genes].astype(float), DIDX[(k, "OBS")][po], nd)
+        for a in ["OBS"] + ARMS[k]:
+            if a == "OBS":
+                mu, var, n, keep = mu_o, var_o, n_o, keep_o
+            else:
+                pg = parent_mask(lab_df(k, a), [P])
+                mu, var, n, keep = gene_stats(GEN[k][a]["markers"][pg][:, genes].astype(float), DIDX[(k, a)][pg], nd)
+            for jj, j in enumerate(genes):
+                m, v = mu[keep, jj], var[keep, jj]
+                gm = np.mean(m)
+                cv2 = np.var(m, ddof=1) / gm ** 2 if gm > 0 and keep.sum() > 2 else np.nan
+                floor2 = np.mean(v / n[keep]) / gm ** 2 if gm > 0 else np.nan
+                phi = np.median(np.where(m > 0.05, (v - m) / np.where(m > 0.05, m, 1) ** 2, np.nan)[m > 0.05]) \
+                    if (m > 0.05).any() else np.nan
+                both = keep & keep_o
+                rho = safe_spearman(mu[both, jj], mu_o[both, jj]) if a != "OBS" else np.nan
+                grows.append({"setting": k, "parent": P, "arm": "OBSERVED" if a == "OBS" else a, "gene": SYMS[j],
+                              "mean_count": gm, "between_donor_cv_raw": np.sqrt(cv2) if np.isfinite(cv2) else np.nan,
+                              "between_donor_cv_floor_removed": np.sqrt(max(cv2 - floor2, 0))
+                              if np.isfinite(cv2) and np.isfinite(floor2) else np.nan,
+                              "within_donor_excess_dispersion": phi, "spearman_donor_means_vs_obs": rho,
+                              "n_donors": int(keep.sum())})
+    print(f"{k}: marker spread done ({time.time() - t0:.1f}s)", flush=True)
+G = pd.DataFrame(grows)
+write(G, "collapse_markers_pergene")
+obs_g = G[G.arm == "OBSERVED"].set_index(["setting", "parent", "gene"])
+for r in G.groupby(["setting", "parent", "arm"], sort=False):
+    (k, P, a), t = r
+    o = obs_g.loc[[(k, P, gname) for gname in t.gene]]
+    cv_ratio = t.between_donor_cv_floor_removed.to_numpy() / o.between_donor_cv_floor_removed.to_numpy()
+    rows.append({"setting": k, "parent": P, "arm": a,
+                 "arm_class": "observed" if a == "OBSERVED" else ARM_CLASS[k][a], "n_genes": len(t),
+                 "median_between_donor_cv_floor_removed": float(np.nanmedian(t.between_donor_cv_floor_removed)),
+                 "median_cv_ratio_gen_over_obs": float(np.nanmedian(cv_ratio)),
+                 "frac_genes_cv_lt_half_obs": float(np.nanmean(cv_ratio < 0.5)),
+                 "median_within_donor_excess_dispersion": float(np.nanmedian(t.within_donor_excess_dispersion)),
+                 "median_spearman_donor_means_vs_obs": float(np.nanmedian(t.spearman_donor_means_vs_obs)),
+                 "min_n_donors": int(t.n_donors.min())})
+write(pd.DataFrame(rows), "collapse_markers")
+
+# ----------------------------------------------------------------------------------------------------- (e) small n
+rows = []
+for k in SETTINGS:
+    for name, A, Bg in ss.CONTRASTS:
+        ia, ib = np.isin(GRP[k], A), np.isin(GRP[k], Bg)
+        rows.append({"setting": k, "contrast": name, "n_a": int(ia.sum()), "n_b": int(ib.sum()),
+                     "groups_a": "+".join(A), "groups_b": "+".join(Bg),
+                     "small_n_flag_le2": bool(min(ia.sum(), ib.sum()) <= 2)})
+    for gname, c in pd.Series(GRP[k]).value_counts().items():
+        rows.append({"setting": k, "contrast": f"group size: {gname}", "n_a": int(c)})
+write(pd.DataFrame(rows), "groupsizes")
+
+rng_boot2 = np.random.default_rng(SEED)
+rows = []
+for k in SETTINGS:
+    for a in ARMS[k]:
+        for s in [st["name"] for st in STATES]:
+            gs, gp, os_, op = PDON[(k, "V0_screen", s, a)]
+            gpct = np.where(gp > 0, 100 * gs / np.maximum(gp, 1), np.nan)
+            opct = np.where(op > 0, 100 * os_ / np.maximum(op, 1), np.nan)
+            for name, A, Bg in ss.CONTRASTS:
+                ia, ib = np.flatnonzero(np.isin(GRP[k], A)), np.flatnonzero(np.isin(GRP[k], Bg))
+                od = np.nanmean(opct[ia]) - np.nanmean(opct[ib])
+                gd = np.nanmean(gpct[ia]) - np.nanmean(gpct[ib])
+                same = bool(np.sign(od) == np.sign(gd)) if (np.isfinite(od) and np.isfinite(gd)) else None
+                flips, n_loo = 0, 0
+                for d in (np.concatenate([ia, ib]) if same is not None else []):
+                    ja, jb = ia[ia != d], ib[ib != d]
+                    if len(ja) == 0 or len(jb) == 0:
+                        continue
+                    od2 = np.nanmean(opct[ja]) - np.nanmean(opct[jb])
+                    gd2 = np.nanmean(gpct[ja]) - np.nanmean(gpct[jb])
+                    if not (np.isfinite(od2) and np.isfinite(gd2)):
+                        continue
+                    n_loo += 1
+                    flips += int(bool(np.sign(od2) == np.sign(gd2)) != same)
+                ba = ia[rng_boot2.integers(0, len(ia), size=(NBOOT, len(ia)))]
+                bb = ib[rng_boot2.integers(0, len(ib), size=(NBOOT, len(ib)))]
+                odb = np.nanmean(opct[ba], 1) - np.nanmean(opct[bb], 1)
+                gdb = np.nanmean(gpct[ba], 1) - np.nanmean(gpct[bb], 1)
+                okb = np.isfinite(odb) & np.isfinite(gdb)
+                rows.append({"setting": k, "arm": a, "arm_class": ARM_CLASS[k][a], "state": s, "contrast": name,
+                             "n_a": len(ia), "n_b": len(ib), "small_n_flag_le2": min(len(ia), len(ib)) <= 2,
+                             "gen_state_a": int(gs[ia].sum()), "gen_state_b": int(gs[ib].sum()),
+                             "gen_parent_a": int(gp[ia].sum()), "gen_parent_b": int(gp[ib].sum()),
+                             "obs_state_a": int(os_[ia].sum()), "obs_state_b": int(os_[ib].sum()),
+                             "low_gen_count_flag_lt10": int(gs[ia].sum() + gs[ib].sum()) < 10,
+                             "obs_diff": od, "gen_diff": gd, "same_direction": same,
+                             "loo_n": n_loo, "loo_flips": flips,
+                             "loo_stable": (flips == 0) if n_loo > 0 else None,
+                             "boot_p_same_direction": float(np.mean(np.sign(odb[okb]) == np.sign(gdb[okb])))
+                             if okb.any() else np.nan})
+SMALLN = pd.DataFrame(rows)
+# consistency with the screen's own contrast table
+chk = []
+for k in SETTINGS:
+    m = SMALLN[SMALLN.setting == k].merge(cons[k], on=["arm", "state", "contrast"], suffixes=("", "_screen"))
+    chk.append({"setting": k, "rows": len(m), "same_direction_mismatch": int((m.same_direction.astype(bool) !=
+                                                                               m.same_direction_screen).sum())})
+print(pd.DataFrame(chk).to_string(index=False), flush=True)
+write(SMALLN, "smalln")
+
+# ------------------------------------------------------------------------------------------------------ (f) controls
+CTRL = DM[DM.state.isin(CONTROLS)].copy()
+write(CTRL, "controls")
+
+# ------------------------------------------------------------------------------ ordering verdict (summary of c, f)
+# V1_lib is not a valid depth reference for the cross-cohort scratch arms: their library is ~10x the observed one but
+# the extracted marker genes carry ~0.1 % of it (observed ~1.2 %), so library-ratio thinning removes ~95 % of their
+# marker counts (see confound_depth.csv, marker_share_median).  It is reported in depthmatch*.csv but excluded here
+# for loco.  Robust = same arm closer to gen/obs = 1 in every valid scheme and donor-bootstrap P >= 0.8 (or <= 0.2).
+rows = []
+for (k, s, pair), t in PAIRDF[PAIRDF.state.isin(FOCUS + CONTROLS)].groupby(["setting", "state", "pair"], sort=False):
+    t = t.set_index("scheme")
+    valid = ["V0_screen", "V1_lib", "V2_msum", "V3_mmed"] if k == "fold0" else ["V0_screen", "V2_msum", "V3_mmed"]
+    cl = [t.loc[v, "closer_to_1"] for v in valid]
+    ps = [t.loc[v, "boot_p_scratch_closer"] for v in valid]
+    if all(c == "scratch" for c in cl) and min(ps) >= 0.8:
+        verdict = "scratch closer, robust"
+    elif all(c == "pretrained" for c in cl) and max(ps) <= 0.2:
+        verdict = "pretrained closer, robust"
+    elif len(set(cl)) == 1:
+        verdict = f"{cl[0]} closer in all valid schemes, bootstrap-uncertain"
+    else:
+        verdict = "scheme-dependent"
+    both_low = all(max(t.loc[v, "scratch_gen_over_obs"], t.loc[v, "pretrained_gen_over_obs"]) < 0.25
+                   for v in ["V0_screen", "V2_msum"])
+    # preferred pair of schemes: the screen as published (V0) and the marker-sum depth match (V2); V3 is a stress test
+    c02 = [t.loc[v, "closer_to_1"] for v in ("V0_screen", "V2_msum")]
+    p02 = [t.loc[v, "boot_p_scratch_closer"] for v in ("V0_screen", "V2_msum")]
+    v02 = ("scratch closer, robust" if all(c == "scratch" for c in c02) and min(p02) >= 0.8 else
+           "pretrained closer, robust" if all(c == "pretrained" for c in c02) and max(p02) <= 0.2 else
+           f"{c02[0]} closer in V0 and V2, bootstrap-uncertain" if c02[0] == c02[1] else "flips between V0 and V2")
+    # donor-equal weighting (mean of per-donor %) instead of pooled counts
+    dmc = {}
+    for v in ("V0_screen", "V2_msum"):
+        a_s = abs_log2(DMI.loc[(k, v, s, t.scratch_arm.iloc[0]), "gen_over_obs_donor_mean"])
+        a_p = abs_log2(DMI.loc[(k, v, s, t.pretrained_arm.iloc[0]), "gen_over_obs_donor_mean"])
+        a_s, a_p = (np.inf if np.isnan(a_s) else a_s), (np.inf if np.isnan(a_p) else a_p)
+        dmc[v] = "scratch" if a_s < a_p else "pretrained" if a_p < a_s else "tie"
+    rows.append({"setting": k, "state": s, "pair": pair, "scratch_arm": t.scratch_arm.iloc[0],
+                 "pretrained_arm": t.pretrained_arm.iloc[0], "valid_schemes": ";".join(valid),
+                 "closer_by_scheme": ";".join(f"{v}={c}" for v, c in zip(valid, cl)),
+                 "boot_p_scratch_closer_min": float(np.nanmin(ps)), "boot_p_scratch_closer_max": float(np.nanmax(ps)),
+                 "verdict": verdict, "verdict_V0_V2": v02,
+                 "boot_p_scratch_closer_V0": p02[0], "boot_p_scratch_closer_V2": p02[1],
+                 "closer_donor_mean_weighting_V0": dmc["V0_screen"], "closer_donor_mean_weighting_V2": dmc["V2_msum"],
+                 "both_arms_below_0.25_in_V0_and_V2": both_low,
+                 "scratch_g_o_V0": t.loc["V0_screen", "scratch_gen_over_obs"],
+                 "pretrained_g_o_V0": t.loc["V0_screen", "pretrained_gen_over_obs"],
+                 "scratch_g_o_V2": t.loc["V2_msum", "scratch_gen_over_obs"],
+                 "pretrained_g_o_V2": t.loc["V2_msum", "pretrained_gen_over_obs"],
+                 "scratch_g_o_V1": t.loc["V1_lib", "scratch_gen_over_obs"],
+                 "pretrained_g_o_V1": t.loc["V1_lib", "pretrained_gen_over_obs"],
+                 "V1_valid": k == "fold0"})
+write(pd.DataFrame(rows), "ordering_verdict")
+print(pd.DataFrame(rows)[["setting", "state", "pair", "verdict", "verdict_V0_V2", "both_arms_below_0.25_in_V0_and_V2",
+                          "boot_p_scratch_closer_V0", "boot_p_scratch_closer_V2"]].round(2).to_string(index=False))
+print(f"done in {time.time() - t0:.1f}s", flush=True)

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/cross_analysis.py

@@ -0,0 +1,401 @@
+#!/usr/bin/env python3
+"""Rare states, cross-cohort setting: from scratch vs pretrained (CPU only, 2026-10-05).
+
+Setting: plans/paired_crosscohort_20261002 split hoL_ye2026_sepsis.  All 82 usable Ye 2026 sepsis donors are held out;
+the models trained on ImMicro + Imperial + Giroux + Liu pairs only.  Reads (never writes) the rare-state screen outputs
+out/sepsis_loco_{summary,contrasts,per_donor}.csv, the per-cell extracts work/sepsis/loco/<arm>.npz and the benchmark
+summaries plans/paired_crosscohort_20261002/scores/ye2026_sepsis/<arm>/summary.json.  Writes only
+out/scratch_vs_lora_20261005/cross_*.csv.
+
+ratio (= gen_over_obs) = [sum gen_state / sum gen_parent] / [sum obsthin_state / sum obs_parent], pooled over donors.
+Fidelity = |log2 ratio| (0 = the observed frequency).
+Bootstrap: donors resampled with replacement, B = 2000, numpy default_rng(20261005).integers(0, 82, (2000, 82)) over the
+donors in sorted order; ONE index matrix shared by every arm, state, reference and comparison (so every comparison is
+paired).  0.5 is added to the pooled state counts (generated and observed) in the point estimate and in every replicate.
+D = |log2 ratio_scratch| - |log2 ratio_comparator|; 95 % percentile CI.  D > 0 with CI > 0: comparator closer.
+Reference variants:
+  own_ref               each arm against its own depth-thinned observed counts (the screen's definition; primary).
+  pretrained_depth_ref  the scratch arm against the comparator's thinned observed counts (vs xcal and vs scratch arms:
+                        the LoRA r16 reference).  Reason: the scratch model's cells have a ~20,000-UMI median library,
+                        so the screen did not thin the observed cells for it (thin = 1), but their marker-gene detection
+                        equals that of the ~1,000-UMI pretrained cross-cohort arms (cross_depth_check.csv).
+Contrasts: recomputed from the per-donor CSV exactly as tools/sepsis_states.py (difference of donor-mean percentages)
+and checked against out/sepsis_loco_contrasts.csv.  eligible_own: informative state and |obs_diff| >= 0.5 pp in that
+arm; eligible_common: |obs_diff| >= 0.5 pp with the same observed sign in all 12 arms (one pair set for every arm).
+Outputs: cross_state_table.csv (step 1), cross_bootstrap.csv (step 2, per state), cross_bootstrap_aggregate.csv (mean
+|log2| per arm and mean D per comparison over the 13 informative non-control states), cross_arm_ci.csv (per-arm ratio and
+Spearman CIs), cross_contrasts.csv + cross_contrast_counts.csv (step 3), cross_spearman.csv (step 4),
+cross_depth_check.csv (library vs marker detection per arm and parent), cross_run.log (console).
+usage: PYTHONDONTWRITEBYTECODE=1 CUDA_VISIBLE_DEVICES= python cross_analysis.py | tee cross_run.log
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from scipy.stats import rankdata
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/rare_states_screen_20261004")
+OUTD = PLAN / "out/scratch_vs_lora_20261005"
+SCORES = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/paired_crosscohort_20261002/"
+              "scores/ye2026_sepsis")
+sys.dont_write_bytecode = True  # never write into tools/
+sys.path.insert(0, str(PLAN / "tools"))
+from screen import parent_mask  # noqa: E402
+
+SEED, B, PSEUDO, MIN_OBS, MIN_DIFF = 20261005, 2000, 0.5, 30, 0.5
+ARMS = ["zs__raw", "xcalL_K1000", "locoL_lora16sat_s26750_K1000", "locoL_lora64sat_s59000_K1000",
+        "locoL_fullsat_s20000_K1000", "locoL_fullsat_s108500_K1000", "locoL_scratchsat_s50000_K1000",
+        "locoL_scratchsat_s100000_K1000", "locoL_scratchsat_s150000_K1000", "locoL_scratchsat_s162000_K1000",
+        "lora_n5__raw", "real_lora__raw"]
+ZS, XCAL, L16, L64, F20, F108, S50, S100, S150, S162, OWN5, OWN58 = ARMS
+SCRATCH = [S50, S100, S150, S162]
+PRE_LOCO = [L16, L64, F20, F108]
+CONTROLS = ["ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"]
+# (scratch arm, comparator, kind, comparator reference used for the scratch arm in the pretrained_depth_ref variant)
+COMPARISONS = [(S162, L16, "main", L16), (S162, L64, "main", L64), (S162, F108, "main", F108),
+               (S162, XCAL, "main", L16),
+               (S162, F20, "extra", F20), (S50, L16, "extra", L16),
+               (S162, S50, "trajectory", L16), (S162, S100, "trajectory", L16), (S162, S150, "trajectory", L16)]
+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"])]
+
+
+def spearman(x: np.ndarray, y: np.ndarray) -> float:
+    ok = ~(np.isnan(x) | np.isnan(y))
+    x, y = x[ok], y[ok]
+    if len(x) < 3:
+        return np.nan
+    rx, ry = rankdata(x), rankdata(y)
+    if rx.std() == 0 or ry.std() == 0:
+        return np.nan
+    return float(np.corrcoef(rx, ry)[0, 1])
+
+
+def spearman_rows(X: np.ndarray, Y: np.ndarray) -> np.ndarray:
+    """Row-wise Spearman (average ranks, NaN pairs dropped) of (B, m) arrays; equals spearman() row by row."""
+    bad = np.isnan(X) | np.isnan(Y)
+    X, Y = np.where(bad, np.nan, X), np.where(bad, np.nan, Y)
+    R1, R2 = rankdata(X, axis=1, nan_policy="omit"), rankdata(Y, axis=1, nan_policy="omit")
+    cnt = (~bad).sum(1)
+    with np.errstate(invalid="ignore", divide="ignore"):
+        d1 = R1 - np.nanmean(R1, 1, keepdims=True)
+        d2 = R2 - np.nanmean(R2, 1, keepdims=True)
+        den = np.sqrt(np.nansum(d1 * d1, 1) * np.nansum(d2 * d2, 1))
+        rho = np.nansum(d1 * d2, 1) / den
+    rho[(cnt < 3) | ~(den > 1e-12)] = np.nan
+    return rho
+
+
+def pct(state: np.ndarray, parent: np.ndarray) -> np.ndarray:
+    with np.errstate(invalid="ignore", divide="ignore"):
+        return np.where(parent > 0, 100.0 * state / np.where(parent > 0, parent, 1), np.nan)
+
+
+def main() -> None:
+    out = PLAN / "out"
+    S = pd.read_csv(out / "sepsis_loco_summary.csv")
+    C = pd.read_csv(out / "sepsis_loco_contrasts.csv")
+    P = pd.read_csv(out / "sepsis_loco_per_donor.csv")
+    assert sorted(S.arm.unique()) == sorted(ARMS), S.arm.unique()
+    states = list(S.state.drop_duplicates())
+    donors = sorted(P.donor.unique())
+    n = len(donors)
+    groups = P.drop_duplicates("donor").set_index("donor").group.reindex(donors).to_numpy()
+
+    # ---- per-donor arrays ---------------------------------------------------------------------------------------
+    A = {}
+    for (arm, st), t in P.groupby(["arm", "state"], sort=False):
+        t = t.set_index("donor").reindex(donors)
+        A[arm, st] = {k: t[k].to_numpy(dtype=float) for k in
+                      ["gen_state", "gen_parent", "obsthin_state", "obs_parent", "obs_state"]}
+    # obs_parent is the same for every arm (one observed cell set)
+    for st in states:
+        for arm in ARMS:
+            assert np.array_equal(A[arm, st]["obs_parent"], A[ARMS[0], st]["obs_parent"])
+
+    # ---- sanity: reproduce the screen's summary from the per-donor table -----------------------------------------
+    for _, r in S.iterrows():
+        a = A[r.arm, r.state]
+        ro = a["obsthin_state"].sum() / max(a["obs_parent"].sum(), 1)
+        rg = a["gen_state"].sum() / max(a["gen_parent"].sum(), 1)
+        assert np.isclose(rg / ro, r.gen_over_obs, rtol=1e-9), (r.arm, r.state)
+        rho = spearman(pct(a["gen_state"], a["gen_parent"]), pct(a["obsthin_state"], a["obs_parent"]))
+        assert (np.isnan(rho) and np.isnan(r.spearman_donors)) or np.isclose(rho, r.spearman_donors, atol=1e-9), \
+            (r.arm, r.state, rho, r.spearman_donors)
+
+    # ---- 1. state table ----------------------------------------------------------------------------------------
+    rows = []
+    for st in states:
+        s = S[S.state == st].set_index("arm")
+        obsthin = {arm: int(A[arm, st]["obsthin_state"].sum()) for arm in ARMS}
+        row = {"state": st, "is_control": st in CONTROLS,
+               "obs_native_state_cells": int(A[ARMS[0], st]["obs_state"].sum()),
+               "obs_parent_cells": int(A[ARMS[0], st]["obs_parent"].sum()),
+               "obs_thinned_state_cells_min": min(obsthin.values()),
+               "obs_thinned_state_cells_max": max(obsthin.values()),
+               "informative": min(obsthin.values()) >= MIN_OBS}
+        for arm in ARMS:
+            row[f"gen_over_obs__{arm}"] = s.loc[arm, "gen_over_obs"]
+        for arm in ARMS:
+            row[f"abs_log2__{arm}"] = abs(np.log2(s.loc[arm, "gen_over_obs"])) if s.loc[arm, "gen_over_obs"] > 0 \
+                else np.inf
+        for arm in ARMS:
+            row[f"spearman_donors__{arm}"] = s.loc[arm, "spearman_donors"]
+        for arm in ARMS:
+            row[f"obs_thinned_state_cells__{arm}"] = obsthin[arm]
+        for arm in ARMS:
+            row[f"gen_state_cells__{arm}"] = int(A[arm, st]["gen_state"].sum())
+        for arm in ARMS:
+            row[f"thin__{arm}"] = s.loc[arm, "thin"]
+        rows.append(row)
+    ST = pd.DataFrame(rows)
+    ST.to_csv(OUTD / "cross_state_table.csv", index=False)
+    informative = dict(zip(ST.state, ST.informative))
+
+    # ---- bootstrap machinery ------------------------------------------------------------------------------------
+    rng = np.random.default_rng(SEED)
+    idx = rng.integers(0, n, size=(B, n))
+    W = np.zeros((B, n))
+    for b in range(B):
+        W[b] = np.bincount(idx[b], minlength=n)
+
+    def log2_ratio(gen_arm: str, ref_arm: str, st: str, pseudo: float = PSEUDO) -> tuple[float, np.ndarray]:
+        g, o = A[gen_arm, st], A[ref_arm, st]
+        with np.errstate(divide="ignore", invalid="ignore"):
+            pt = np.log2(((g["gen_state"].sum() + pseudo) / g["gen_parent"].sum())
+                         / ((o["obsthin_state"].sum() + pseudo) / o["obs_parent"].sum()))
+            bs = np.log2(((W @ g["gen_state"] + pseudo) / (W @ g["gen_parent"]))
+                         / ((W @ o["obsthin_state"] + pseudo) / (W @ o["obs_parent"])))
+        return float(pt), bs
+
+    def raw_ratio(gen_arm: str, ref_arm: str, st: str) -> float:
+        g, o = A[gen_arm, st], A[ref_arm, st]
+        ro = o["obsthin_state"].sum() / o["obs_parent"].sum()
+        return float((g["gen_state"].sum() / g["gen_parent"].sum()) / ro) if ro > 0 else np.nan
+
+    def spearman_boot(gen_arm: str, ref_arm: str, st: str) -> tuple[float, np.ndarray]:
+        g, o = A[gen_arm, st], A[ref_arm, st]
+        x, y = pct(g["gen_state"], g["gen_parent"]), pct(o["obsthin_state"], o["obs_parent"])
+        return spearman(x, y), spearman_rows(x[idx], y[idx])
+
+    # sanity: the vectorised Spearman equals the scalar one, incl. a donor with no generated parent cells
+    for arm, st in [(F108, "C1Q-high monocyte (reference)"), (S162, "Cycling T/NK"), (L16, "HSPC")]:
+        g = A[arm, st]
+        x, y = pct(g["gen_state"], g["gen_parent"]), pct(g["obsthin_state"], g["obs_parent"])
+        v, s_ = spearman_rows(x[idx[:50]], y[idx[:50]]), np.array([spearman(x[i], y[i]) for i in idx[:50]])
+        assert np.allclose(v, s_, equal_nan=True), (arm, st)
+
+    # ---- per-arm CIs (ratio and Spearman), own reference + scratch arms at pretrained depth ------------------------
+    cache_sp = {}
+    rows = []
+    for st in states:
+        for arm in ARMS:
+            refs = [("own_ref", arm)] + ([("pretrained_depth_ref:" + r, r) for r in PRE_LOCO] if arm in SCRATCH else [])
+            for variant, ref in refs:
+                pt, bs = log2_ratio(arm, ref, st)
+                sp_pt, sp_bs = spearman_boot(arm, ref, st)
+                cache_sp[arm, ref, st] = (sp_pt, sp_bs)
+                lo, hi = np.nanpercentile(bs, [2.5, 97.5])
+                slo, shi = (np.nanpercentile(sp_bs, [2.5, 97.5]) if np.isfinite(sp_bs).sum() > 0 else (np.nan, np.nan))
+                rows.append({"state": st, "is_control": st in CONTROLS, "informative": informative[st], "arm": arm,
+                             "variant": variant.split(":")[0], "observed_reference_arm": ref,
+                             "gen_state": int(A[arm, st]["gen_state"].sum()),
+                             "gen_parent": int(A[arm, st]["gen_parent"].sum()),
+                             "obsthin_state": int(A[ref, st]["obsthin_state"].sum()),
+                             "obs_parent": int(A[ref, st]["obs_parent"].sum()),
+                             "ratio": raw_ratio(arm, ref, st), "ratio_ps": 2 ** pt,
+                             "ratio_ps_ci_lo": 2 ** lo, "ratio_ps_ci_hi": 2 ** hi,
+                             "abs_log2_ps": abs(pt), "spearman_donors": sp_pt,
+                             "spearman_ci_lo": slo, "spearman_ci_hi": shi})
+    AC = pd.DataFrame(rows)
+    AC.to_csv(OUTD / "cross_arm_ci.csv", index=False)
+
+    # ---- 2. paired bootstrap of D -------------------------------------------------------------------------------
+    rows = []
+    for scr, comp, kind, depth_ref in COMPARISONS:
+        variants = [("own_ref", scr, comp)]
+        if kind != "trajectory":
+            variants.append(("pretrained_depth_ref", depth_ref, comp))
+        else:  # both scratch arms at the LoRA r16 depth
+            variants.append(("pretrained_depth_ref", depth_ref, depth_ref))
+        for variant, ref_s, ref_c in variants:
+            for st in states:
+                ps, bs_s = log2_ratio(scr, ref_s, st)
+                pc, bs_c = log2_ratio(comp, ref_c, st)
+                D, Db = abs(ps) - abs(pc), np.abs(bs_s) - np.abs(bs_c)
+                lo, hi = np.nanpercentile(Db, [2.5, 97.5])
+                verdict = ("comparator_closer_sig" if lo > 0 else "scratch_closer_sig" if hi < 0 else "not_significant")
+                rows.append({"comparison": f"{scr} vs {comp}", "kind": kind, "variant": variant, "state": st,
+                             "is_control": st in CONTROLS, "informative": informative[st],
+                             "scratch_arm": scr, "comparator_arm": comp,
+                             "scratch_reference": ref_s, "comparator_reference": ref_c,
+                             "ratio_scratch": raw_ratio(scr, ref_s, st), "ratio_comparator": raw_ratio(comp, ref_c, st),
+                             "ratio_scratch_ps": 2 ** ps, "ratio_comparator_ps": 2 ** pc,
+                             "abs_log2_scratch": abs(ps), "abs_log2_comparator": abs(pc),
+                             "D": D, "D_ci_lo": lo, "D_ci_hi": hi, "D_boot_median": float(np.nanmedian(Db)),
+                             "frac_boot_D_gt0": float(np.mean(Db > 0)), "verdict": verdict,
+                             "n_boot": B, "seed": SEED, "pseudocount": PSEUDO})
+    BT = pd.DataFrame(rows)
+    BT.to_csv(OUTD / "cross_bootstrap.csv", index=False)
+
+    # ---- aggregate over the informative non-control states: mean |log2| per arm, mean D per comparison --------------
+    rare = [s for s in states if informative[s] and s not in CONTROLS]
+    assert len(rare) == 13, rare
+    rows = []
+    for arm in ARMS:
+        for variant, ref in [("own_ref", arm)] + ([("pretrained_depth_ref", L16)] if arm in SCRATCH else []):
+            pts, bss = zip(*[log2_ratio(arm, ref, s) for s in rare])
+            a_pt, a_bs = np.abs(np.array(pts)), np.abs(np.vstack(bss))
+            raw = np.array([raw_ratio(arm, ref, s) for s in rare])
+            lo, hi = np.nanpercentile(a_bs.mean(0), [2.5, 97.5])
+            rows.append({"kind": "arm", "arm_or_comparison": arm, "variant": variant, "observed_reference": ref,
+                         "n_states": len(rare), "mean_abs_log2": a_pt.mean(), "ci_lo": lo, "ci_hi": hi,
+                         "median_abs_log2": float(np.median(a_pt)),
+                         "n_states_within_2fold": int(((raw >= 0.5) & (raw <= 2)).sum()),
+                         "n_states_below_0.25x": int((raw < 0.25).sum()), "n_states_above_2x": int((raw > 2).sum()),
+                         "states_within_2fold": "; ".join(s for s, r in zip(rare, raw) if 0.5 <= r <= 2)})
+    for scr, comp, kind, depth_ref in COMPARISONS:
+        for variant, ref_s, ref_c in [("own_ref", scr, comp),
+                                      ("pretrained_depth_ref", depth_ref,
+                                       depth_ref if kind == "trajectory" else comp)]:
+            Ds, Dbs = [], []
+            for s in rare:
+                ps, bs_s = log2_ratio(scr, ref_s, s)
+                pc, bs_c = log2_ratio(comp, ref_c, s)
+                Ds.append(abs(ps) - abs(pc))
+                Dbs.append(np.abs(bs_s) - np.abs(bs_c))
+            Db = np.vstack(Dbs).mean(0)
+            lo, hi = np.nanpercentile(Db, [2.5, 97.5])
+            rows.append({"kind": f"comparison_{kind}", "arm_or_comparison": f"{scr} vs {comp}", "variant": variant,
+                         "observed_reference": f"{ref_s} | {ref_c}", "n_states": len(rare),
+                         "mean_D": float(np.mean(Ds)), "ci_lo": lo, "ci_hi": hi, "median_D": float(np.median(Ds)),
+                         "frac_boot_mean_D_gt0": float(np.mean(Db > 0))})
+    pd.DataFrame(rows).to_csv(OUTD / "cross_bootstrap_aggregate.csv", index=False)
+
+    # ---- 4. Spearman differences ----------------------------------------------------------------------------------
+    rows = []
+    for scr, comp, kind, depth_ref in COMPARISONS:
+        for variant, ref_s, ref_c in [("own_ref", scr, comp)] + (
+                [("pretrained_depth_ref", depth_ref, comp)] if kind != "trajectory" else []):
+            for st in states:
+                if (scr, ref_s, st) not in cache_sp:
+                    cache_sp[scr, ref_s, st] = spearman_boot(scr, ref_s, st)
+                if (comp, ref_c, st) not in cache_sp:
+                    cache_sp[comp, ref_c, st] = spearman_boot(comp, ref_c, st)
+                (a, ab), (c, cb) = cache_sp[scr, ref_s, st], cache_sp[comp, ref_c, st]
+                d = ab - cb
+                ok = np.isfinite(d)
+                lo, hi = (np.percentile(d[ok], [2.5, 97.5]) if ok.sum() > 0 else (np.nan, np.nan))
+                rows.append({"comparison": f"{scr} vs {comp}", "kind": kind, "variant": variant, "state": st,
+                             "is_control": st in CONTROLS, "informative": informative[st],
+                             "spearman_scratch": a, "spearman_comparator": c, "diff_scratch_minus_comparator": a - c,
+                             "diff_ci_lo": lo, "diff_ci_hi": hi, "n_boot_finite": int(ok.sum()),
+                             "verdict": ("scratch_higher_sig" if lo > 0 else
+                                         "comparator_higher_sig" if hi < 0 else "not_significant")})
+    SPD = pd.DataFrame(rows)
+    SPD.to_csv(OUTD / "cross_spearman.csv", index=False)
+
+    # ---- 3. contrasts -------------------------------------------------------------------------------------------
+    rows = []
+    for arm in ARMS:
+        refs = [("own_ref", arm)] + ([("pretrained_depth_ref", L16)] if arm in SCRATCH else [])
+        for variant, ref in refs:
+            for st in states:
+                g, o = A[arm, st], A[ref, st]
+                gp_, op_ = pct(g["gen_state"], g["gen_parent"]), pct(o["obsthin_state"], o["obs_parent"])
+                for name, ga, gb in CONTRASTS:
+                    ma, mb = np.isin(groups, ga), np.isin(groups, gb)
+                    od = np.nanmean(op_[ma]) - np.nanmean(op_[mb])
+                    gd = np.nanmean(gp_[ma]) - np.nanmean(gp_[mb])
+                    rows.append({"arm": arm, "variant": variant, "observed_reference_arm": ref, "state": st,
+                                 "contrast": name, "is_control": st in CONTROLS, "informative": informative[st],
+                                 "obs_diff": od, "gen_diff": gd,
+                                 "same_direction": bool(np.sign(od) == np.sign(gd)),
+                                 "reversed": bool(np.sign(od) * np.sign(gd) < 0), "flat_generated": bool(gd == 0),
+                                 "gen_over_obs_diff": gd / od if od != 0 else np.nan})
+    CT = pd.DataFrame(rows)
+    chk = CT[CT.variant == "own_ref"].merge(C, on=["arm", "state", "contrast"], suffixes=("", "_screen"))
+    assert len(chk) == len(C)
+    assert np.allclose(chk.obs_diff, chk.obs_diff_screen, equal_nan=True)
+    assert np.allclose(chk.gen_diff, chk.gen_diff_screen, equal_nan=True)
+    assert (chk.same_direction == chk.same_direction_screen).all()
+    own = CT[CT.variant == "own_ref"]
+    big_all = own.assign(big=own.obs_diff.abs() >= MIN_DIFF, sgn=np.sign(own.obs_diff)).groupby(
+        ["state", "contrast"]).agg(big_all=("big", "all"), sign_consistent=("sgn", lambda s: s.nunique() == 1))
+    CT = CT.merge(big_all.reset_index(), on=["state", "contrast"], how="left")
+    CT["eligible_own"] = CT.informative & (CT.obs_diff.abs() >= MIN_DIFF)
+    CT["eligible_common"] = CT.informative & CT.big_all & CT.sign_consistent
+    CT.to_csv(OUTD / "cross_contrasts.csv", index=False)
+    rows = []
+    for (arm, variant), t in CT.groupby(["arm", "variant"], sort=False):
+        for scope, ctrl in [("rare_states", False), ("controls", True)]:
+            u = t[t.is_control == ctrl]
+            for elig in ["eligible_own", "eligible_common"]:
+                e = u[u[elig]]
+                rows.append({"arm": arm, "variant": variant, "states": scope, "eligibility": elig,
+                             "n_pairs": len(e), "kept": int(e.same_direction.sum()), "reversed": int(e.reversed.sum()),
+                             "flat": int(e.flat_generated.sum()),
+                             "median_gen_over_obs_diff_kept": float(e[e.same_direction].gen_over_obs_diff.median())
+                             if e.same_direction.any() else np.nan,
+                             "lost_pairs": "; ".join(f"{r.state} | {r.contrast}" for r in e[~e.same_direction].itertuples())})
+    CC = pd.DataFrame(rows)
+    CC.to_csv(OUTD / "cross_contrast_counts.csv", index=False)
+
+    # ---- depth check ----------------------------------------------------------------------------------------------
+    st_json = json.loads((PLAN / "tools/states.json").read_text())
+    parents = []
+    for s in st_json:
+        if s["parent"] not in parents:
+            parents.append(s["parent"])
+    bench_name = {ZS: "zs_K1000"}
+    rows = []
+    for arm in ARMS:
+        d = np.load(PLAN / f"work/sepsis/loco/{arm}.npz", allow_pickle=False)
+        lab = pd.DataFrame({"aifi_l1": d["aifi_l1"], "aifi_l2": d["aifi_l2"]})
+        M, lib = d["markers"], d["lib_measured"]
+        bj = SCORES / bench_name.get(arm, arm) / "summary.json"
+        bench = {}
+        if bj.exists():
+            pa = json.loads(bj.read_text())["per_arm"][bench_name.get(arm, arm)]
+            bench = {"bench_median_umi_gen_scoring_genes": pa["median_umi_per_cell_scoring_genes"]["generated_pooled"],
+                     "bench_median_umi_obs_scoring_genes": pa["median_umi_per_cell_scoring_genes"]["observed_pooled"],
+                     "bench_detected_genes_median_gen": pa["precision_coverage_depth_matched"]["detected_median_before"]["Q"],
+                     "bench_detected_genes_median_obs": pa["precision_coverage_depth_matched"]["detected_median_before"]["R1"],
+                     "bench_precision": pa["precision_coverage"]["precision"],
+                     "bench_coverage": pa["precision_coverage"]["coverage"]}
+        syms = list(d["marker_symbols"].astype(str))
+        for p in parents:
+            m = parent_mask(lab, p)
+            X = M[m]
+            nz = X[X > 0]
+            thin_state = next(s["name"] for s in st_json if s["parent"] == p and s["kind"] == "markers")
+            rows.append({"arm": arm, "parent": "+".join(p), "n_parent_cells": int(m.sum()),
+                         "median_lib_measured": float(np.median(lib[m])),
+                         "mean_detected_marker_genes_of_73": float((X > 0).sum(1).mean()),
+                         "mean_count_per_detected_marker": float(nz.mean()) if nz.size else np.nan,
+                         "screen_thin_constant": float(S[(S.arm == arm) & (S.state == thin_state)].thin.iloc[0]),
+                         # detection of broadly expressed (non-state) marker genes: a depth read-out on the marker panel
+                         **{f"detected_frac__{gname}": float((X[:, syms.index(gname)] > 0).mean())
+                            for gname in ["HLA-DRA", "HLA-DRB1", "ZEB2", "PLAC8", "CD163", "NKG7", "GZMA", "GNLY",
+                                          "CCR7"] if gname in syms},
+                         **bench})
+    pd.DataFrame(rows).to_csv(OUTD / "cross_depth_check.csv", index=False)
+
+    # ---- console summary --------------------------------------------------------------------------------------
+    pd.set_option("display.width", 250, "display.max_columns", 40, "display.max_rows", 400)
+    print("informative:", ST.informative.sum(), "of", len(ST), "| min obs thinned:", ST.obs_thinned_state_cells_min.min())
+    for (comp, variant), t in BT.groupby(["comparison", "variant"], sort=False):
+        u = t[t.informative & ~t.is_control]
+        print(f"{comp} [{variant}]: scratch closer {int((u.verdict == 'scratch_closer_sig').sum())}, comparator closer "
+              f"{int((u.verdict == 'comparator_closer_sig').sum())}, n.s. {int((u.verdict == 'not_significant').sum())}")
+    print(CC[CC.states == "rare_states"].to_string(index=False))
+
+
+if __name__ == "__main__":
+    main()

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_confound_cross_analysis.py

@@ -0,0 +1,727 @@
+#!/usr/bin/env python3
+"""Adversarial confound check of the CROSS-COHORT scratch-vs-pretrained rare-state claims (CPU only; 2026-10-05).
+
+Independent re-implementation (does not import tools/*.py, so nothing is written into tools/__pycache__).
+Read-only inputs:
+  out/sepsis_loco_{summary,per_donor,contrasts}.csv, out/sepsis_fold0_summary.csv
+  work/sepsis/loco/<arm>.npz                                (generated per-cell marker extracts)
+  paired_finetune_intradataset_20260927/data/ye2026_sepsis/{cells_panel6k.npz, cells_obs.parquet, folds.csv}
+  paired_finetune_intradataset_20260927/scoring_cache/ye2026_sepsis/observed_labels/labels/labels.parquet
+  tools/states.json
+Writes only out/scratch_vs_lora_20261005/verify_confound_cross_*.
+
+Checks
+  R   recompute the screen ratio (pooled), plus two re-weighted estimators that remove the donor-weighting /
+      parent-pool mismatch between the generated (1,500 cells per donor) and observed (variable) pools:
+        gw = sum gen_state / sum_d gen_parent_d * obs_thin_rate_d  (generated-weighted expected count)
+        dm = mean_d gen_% / mean_d obs_thin_%                       (donor-balanced)
+      LODO range of each ratio and the largest single-donor share of the state counts.
+  C   scratch (s162000) vs comparators: D = |log2 r_scratch| - |log2 r_comp| for the three estimators, own reference
+      and comparator-depth reference; donor bootstrap (seed 20261005, B 2000, shared index); LODO stability of the
+      bootstrap verdict (82 leave-one-donor-out re-bootstraps, index rng(20261005).integers(0, 81, (2000, 81))).
+  A   13-state aggregate mean D: LODO and leave-one-state-out.
+  DEP detection-matched depth: per arm and parent, the binomial thinning constant t at which the observed cells' expected
+      detection of reference marker genes (observed native detection >= 10 % in the parent, the state's own rule genes
+      excluded) equals the generated detection (per-gene t, median over genes).  Observed cells are then thinned at
+      that t (seed 20261005) and every marker state re-called -> detection-matched ratio and D.
+  LAB label-state validity: cycling / plasma marker support inside the scANVI 'Proliferating T cell' / 'Plasma cell'
+      labelled cells, generated vs observed.
+  CON contrast robustness: chance level, donor-bootstrap (within group) sign stability, LODO, compression at matched
+      depth, paired compression on pairs kept by both arms.
+  SP  Spearman over donors: zero-inflation, CI width, best arm per state.
+  FOLD own-cohort and cross-cohort arms restricted to each within-cohort fold's held-out donors.
+"""
+from __future__ import annotations
+
+import json
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from scipy.stats import binom, rankdata
+
+sys.dont_write_bytecode = True
+T0 = time.time()
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+PLAN = M8 / "plans/rare_states_screen_20261004"
+OUT = PLAN / "out/scratch_vs_lora_20261005"
+PFX = "verify_confound_cross_"
+FT = M8 / "plans/paired_finetune_intradataset_20260927"
+DATA = FT / "data/ye2026_sepsis"
+OBS_LABELS = FT / "scoring_cache/ye2026_sepsis/observed_labels/labels/labels.parquet"
+CANON = Path("/home/sj_server_1/gblee/datalake/paired-pbmc-bulk-sc/processing/strict_qc_v1_20260913/reference/"
+             "canonical_genes.tsv")
+SEED, B, PS = 20261005, 2000, 0.5
+
+ARMS = ["zs__raw", "xcalL_K1000", "locoL_lora16sat_s26750_K1000", "locoL_lora64sat_s59000_K1000",
+        "locoL_fullsat_s20000_K1000", "locoL_fullsat_s108500_K1000", "locoL_scratchsat_s50000_K1000",
+        "locoL_scratchsat_s100000_K1000", "locoL_scratchsat_s150000_K1000", "locoL_scratchsat_s162000_K1000",
+        "lora_n5__raw", "real_lora__raw"]
+SHORT = dict(zip(ARMS, ["zs", "xcal", "r16", "r64", "full20k", "full108k", "s50k", "s100k", "s150k", "s162k",
+                        "own5", "own58"]))
+ZS, XCAL, L16, L64, F20, F108, S50, S100, S150, S162, OWN5, OWN58 = ARMS
+SCRATCH = [S50, S100, S150, S162]
+PRE = [L16, L64, F20, F108]
+CONTROLS = ["ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"]
+CONTRASTS = [("adult", ["adult_sepsis"], ["adult_HC"]),
+             ("paediatric", ["ped_sepsis"], ["ped_HC"]),
+             ("all", ["adult_sepsis", "ped_sepsis"], ["adult_HC", "adult_ICU_ctrl", "ped_HC", "ped_ICU_ctrl"])]
+# (scratch arm, comparator, scratch reference arm in the comparator-depth variant)
+COMPS = [(S162, L16, L16), (S162, L64, L64), (S162, F108, F108), (S162, XCAL, L16), (S162, F20, F20),
+         (S50, L16, L16), (S162, S50, S162)]
+LOG = []
+
+
+def log(*a):
+    s = " ".join(str(x) for x in a)
+    print(s, flush=True)
+    LOG.append(s)
+
+
+def write(df: pd.DataFrame, name: str) -> None:
+    df.to_csv(OUT / f"{PFX}{name}.csv", index=False, na_rep="null")
+
+
+# ------------------------------------------------------------------------------------------------ per-donor table
+P = pd.read_csv(PLAN / "out/sepsis_loco_per_donor.csv")
+S = pd.read_csv(PLAN / "out/sepsis_loco_summary.csv")
+STJ = json.loads((PLAN / "tools/states.json").read_text())
+STATES = [s["name"] for s in STJ]
+RARE = [s for s in STATES if s not in CONTROLS]
+donors = sorted(P.donor.unique())
+n = len(donors)
+groups = P.drop_duplicates("donor").set_index("donor").group.reindex(donors).to_numpy()
+A = {}
+for (arm, st), t in P.groupby(["arm", "state"], sort=False):
+    t = t.set_index("donor").reindex(donors)
+    A[arm, st] = {k: t[k].to_numpy(float) for k in ["gen_state", "gen_parent", "obsthin_state", "obs_parent",
+                                                     "obs_state"]}
+THIN = {(r.arm, r.state): r.thin for r in S.itertuples()}
+assert len(RARE) == 13 and n == 82
+
+rng = np.random.default_rng(SEED)
+IDX = rng.integers(0, n, size=(B, n))
+W = np.stack([np.bincount(r, minlength=n) for r in IDX]).astype(float)
+IDX81 = np.random.default_rng(SEED).integers(0, n - 1, size=(B, n - 1))
+W81 = np.stack([np.bincount(r, minlength=n - 1) for r in IDX81]).astype(float)
+
+
+def vecs(gen_arm, ref_arm, st, obs_override=None):
+    g, o = A[gen_arm, st], A[ref_arm, st]
+    os_ = o["obsthin_state"] if obs_override is None else obs_override
+    return g["gen_state"], g["gen_parent"], os_, o["obs_parent"]
+
+
+def lr(est, gs, gp, os_, op, w=None):
+    """log2 ratio with a 0.5-cell pseudocount on both state counts. w: (B, m) weights or None."""
+    with np.errstate(divide="ignore", invalid="ignore"):
+        if est == "pool":
+            if w is None:
+                return np.log2(((gs.sum() + PS) / gp.sum()) / ((os_.sum() + PS) / op.sum()))
+            return np.log2(((w @ gs + PS) / (w @ gp)) / ((w @ os_ + PS) / (w @ op)))
+        if est == "gw":
+            ok = op > 0
+            e = np.where(ok, gp * os_ / np.where(ok, op, 1), 0.0)
+            g = np.where(ok, gs, 0.0)
+            if w is None:
+                return np.log2((g.sum() + PS) / (e.sum() + PS))
+            return np.log2((w @ g + PS) / (w @ e + PS))
+        if est == "dm":
+            ok = (gp > 0) & (op > 0)
+            gpct = np.where(ok, gs / np.where(gp > 0, gp, 1), 0.0)
+            opct = np.where(ok, os_ / np.where(op > 0, op, 1), 0.0)
+            eg, eo = PS / gp.sum(), PS / op.sum()
+            if w is None:
+                return np.log2((gpct[ok].mean() + eg) / (opct[ok].mean() + eo))
+            wk = w * ok
+            den = wk.sum(1)
+            return np.log2(((wk @ gpct) / den + eg) / ((wk @ opct) / den + eo))
+    raise ValueError(est)
+
+
+def raw_ratio(gs, gp, os_, op):
+    ro = os_.sum() / op.sum()
+    return float((gs.sum() / gp.sum()) / ro) if ro > 0 and gp.sum() > 0 else np.nan
+
+
+def verdict(lo, hi):
+    return "comparator_closer_sig" if lo > 0 else "scratch_closer_sig" if hi < 0 else "not_significant"
+
+
+# ------------------------------------------------------------------------------------------------ R: ratios
+log("== R: ratios, re-weighted estimators, LODO ==")
+rows = []
+for st in STATES:
+    for arm in ARMS:
+        refs = [("own_ref", arm)] + ([("r16_depth_ref", L16)] if arm in SCRATCH else [])
+        for variant, ref in refs:
+            gs, gp, os_, op = vecs(arm, ref, st)
+            row = {"state": st, "arm": SHORT[arm], "variant": variant, "gen_state": int(gs.sum()),
+                   "gen_parent": int(gp.sum()), "obsthin_state": int(os_.sum()), "obs_parent": int(op.sum()),
+                   "ratio_pool_raw": raw_ratio(gs, gp, os_, op)}
+            for est in ["pool", "gw", "dm"]:
+                pt = lr(est, gs, gp, os_, op)
+                bs = lr(est, gs, gp, os_, op, W)
+                lo, hi = np.nanpercentile(bs, [2.5, 97.5])
+                row.update({f"ratio_{est}": 2 ** pt, f"ratio_{est}_lo": 2 ** lo, f"ratio_{est}_hi": 2 ** hi})
+            # LODO of the pooled ratio (pseudocount version)
+            lodo = np.array([lr("pool", np.delete(gs, j), np.delete(gp, j), np.delete(os_, j), np.delete(op, j))
+                             for j in range(n)])
+            row.update({"lodo_ratio_min": 2 ** lodo.min(), "lodo_ratio_max": 2 ** lodo.max(),
+                        "lodo_most_influential_donor": donors[int(np.argmax(np.abs(lodo - lr("pool", gs, gp, os_, op))))],
+                        "max_donor_share_gen_state": float(gs.max() / gs.sum()) if gs.sum() > 0 else np.nan,
+                        "max_donor_share_obsthin_state": float(os_.max() / os_.sum()) if os_.sum() > 0 else np.nan,
+                        "donors_with_0_gen_state": int((gs == 0).sum()),
+                        "donors_with_gen_parent": int((gp > 0).sum())})
+            rows.append(row)
+R = pd.DataFrame(rows)
+write(R, "ratios")
+key = R[(R.variant == "own_ref") & R.state.isin(["C1Q-high monocyte (reference)", "MS1 monocyte (IL1R2+)",
+                                                 "Cycling T/NK", "Cycling monocyte (Ye 2026)",
+                                                 "Cycling activated T (CD38/HLA-DR)", "Proliferating T (label)",
+                                                 "HSPC", "Cytotoxic CD4 T", "Plasmablast (label)"])]
+with pd.option_context("display.width", 250, "display.max_rows", 300, "display.max_columns", 30):
+    log(key[["state", "arm", "ratio_pool_raw", "ratio_pool", "ratio_pool_lo", "ratio_pool_hi", "ratio_gw", "ratio_dm",
+             "lodo_ratio_min", "lodo_ratio_max", "max_donor_share_gen_state", "max_donor_share_obsthin_state"]]
+        .round(3).to_string(index=False))
+
+
+# ------------------------------------------------------------------------------------------------ C: comparisons
+log("== C: scratch vs comparators, three estimators, LODO-bootstrap stability ==")
+
+
+def comp_boot(scr, comp, ref_s, ref_c, st, est, w=None, drop=None):
+    gs, gp, os_, op = vecs(scr, ref_s, st)
+    cs, cp, co, cop = vecs(comp, ref_c, st)
+    if drop is not None:
+        gs, gp, os_, op, cs, cp, co, cop = (np.delete(v, drop) for v in (gs, gp, os_, op, cs, cp, co, cop))
+    return np.abs(lr(est, gs, gp, os_, op, w)) - np.abs(lr(est, cs, cp, co, cop, w))
+
+
+rows = []
+for scr, comp, dref in COMPS:
+    for variant, ref_s, ref_c in [("own_ref", scr, comp), ("comparator_depth_ref", dref, comp if comp not in SCRATCH else dref)]:
+        if comp in SCRATCH and variant == "comparator_depth_ref":
+            ref_s = ref_c = L16
+        for st in STATES:
+            for est in ["pool", "gw", "dm"]:
+                D = float(comp_boot(scr, comp, ref_s, ref_c, st, est))
+                Db = comp_boot(scr, comp, ref_s, ref_c, st, est, W)
+                lo, hi = np.nanpercentile(Db, [2.5, 97.5])
+                v = verdict(lo, hi)
+                row = {"comparison": f"{SHORT[scr]} vs {SHORT[comp]}", "variant": variant, "state": st,
+                       "estimator": est, "D": D, "D_lo": lo, "D_hi": hi, "verdict": v}
+                if est == "pool":
+                    # LODO: point D range and bootstrap verdict stability
+                    pts, same = [], 0
+                    for j in range(n):
+                        pts.append(float(comp_boot(scr, comp, ref_s, ref_c, st, est, drop=j)))
+                        Dj = comp_boot(scr, comp, ref_s, ref_c, st, est, W81, drop=j)
+                        l2, h2 = np.nanpercentile(Dj, [2.5, 97.5])
+                        same += verdict(l2, h2) == v
+                    row.update({"lodo_D_min": min(pts), "lodo_D_max": max(pts),
+                                "lodo_sign_flips": int(sum(np.sign(p) != np.sign(D) for p in pts)),
+                                "lodo_verdict_same_frac": same / n})
+                rows.append(row)
+C = pd.DataFrame(rows)
+write(C, "comparisons")
+Cp = C.pivot_table(index=["comparison", "variant", "state"], columns="estimator", values="verdict",
+                   aggfunc="first").reset_index()
+Cp["estimators_agree"] = (Cp["pool"] == Cp["gw"]) & (Cp["pool"] == Cp["dm"])
+dis = Cp[~Cp.estimators_agree & ~Cp.state.isin(CONTROLS)]
+with pd.option_context("display.width", 250, "display.max_rows", 300):
+    log("verdict disagreements between estimators (rare states):")
+    log(dis.to_string(index=False))
+    u = C[(C.estimator == "pool") & (C.verdict != "not_significant") & ~C.state.isin(CONTROLS)]
+    log("pooled-estimator significant verdicts with LODO stability:")
+    log(u[["comparison", "variant", "state", "D", "D_lo", "D_hi", "verdict", "lodo_D_min", "lodo_D_max",
+           "lodo_verdict_same_frac"]].round(3).to_string(index=False))
+
+# ------------------------------------------------------------------------------------------------ A: aggregate
+log("== A: 13-state aggregate mean D: LODO and leave-one-state-out ==")
+rows = []
+for scr, comp, dref in COMPS:
+    for variant in ["own_ref", "comparator_depth_ref"]:
+        if variant == "own_ref":
+            ref_s, ref_c = scr, comp
+        elif comp in SCRATCH:
+            ref_s = ref_c = L16
+        else:
+            ref_s, ref_c = dref, comp
+        for est in ["pool", "gw", "dm"]:
+            Ds = np.array([float(comp_boot(scr, comp, ref_s, ref_c, s, est)) for s in RARE])
+            Dbs = np.vstack([comp_boot(scr, comp, ref_s, ref_c, s, est, W) for s in RARE])
+            lo, hi = np.nanpercentile(Dbs.mean(0), [2.5, 97.5])
+            row = {"comparison": f"{SHORT[scr]} vs {SHORT[comp]}", "variant": variant, "estimator": est,
+                   "mean_D": Ds.mean(), "lo": lo, "hi": hi, "verdict": verdict(lo, hi)}
+            # leave one state out
+            loso = [(RARE[i], np.delete(Ds, i).mean(), *np.nanpercentile(np.delete(Dbs, i, 0).mean(0), [2.5, 97.5]))
+                    for i in range(len(RARE))]
+            row.update({"loso_mean_D_min": min(x[1] for x in loso), "loso_mean_D_max": max(x[1] for x in loso),
+                        "loso_verdicts": ";".join(sorted({verdict(x[2], x[3]) for x in loso})),
+                        "loso_state_flipping_verdict": ";".join(x[0] for x in loso if verdict(x[2], x[3]) !=
+                                                                 verdict(lo, hi))})
+            if est == "pool":
+                same, pts = 0, []
+                for j in range(n):
+                    Dj = np.vstack([comp_boot(scr, comp, ref_s, ref_c, s, est, W81, drop=j) for s in RARE]).mean(0)
+                    pts.append(np.mean([float(comp_boot(scr, comp, ref_s, ref_c, s, est, drop=j)) for s in RARE]))
+                    l2, h2 = np.nanpercentile(Dj, [2.5, 97.5])
+                    same += verdict(l2, h2) == verdict(lo, hi)
+                row.update({"lodo_mean_D_min": min(pts), "lodo_mean_D_max": max(pts), "lodo_verdict_same_frac": same / n})
+            rows.append(row)
+AG = pd.DataFrame(rows)
+write(AG, "aggregate")
+with pd.option_context("display.width", 250, "display.max_rows", 300, "display.max_columns", 30):
+    log(AG.round(3).to_string(index=False))
+log(f"[{time.time() - T0:.0f}s]")
+
+# ------------------------------------------------------------------------------------------------ observed cells
+log("== loading observed cells (82 donors, 73 marker columns) ==")
+G = {a: np.load(PLAN / f"work/sepsis/loco/{a}.npz", allow_pickle=False) for a in ARMS}
+SYMS = list(G[ZS]["marker_symbols"].astype(str))
+for a in ARMS:
+    assert list(G[a]["marker_symbols"].astype(str)) == SYMS
+d = np.load(DATA / "cells_panel6k.npz", allow_pickle=False)
+panel = d["panel_gene_ids"].astype(str)
+measured = d["panel_measured"].any(0)
+canon = pd.read_csv(CANON, sep="\t", dtype=str)
+sym2id = dict(zip(canon.gene_symbol, canon.gene_id))
+pos = {g: i for i, g in enumerate(panel)}
+cols = np.asarray([pos[sym2id[g]] for g in SYMS])
+X = sp.csr_matrix((d["data"], d["indices"], d["indptr"]), shape=tuple(d["shape"]))
+obs = pd.read_parquet(DATA / "cells_obs.parquet", columns=["sample_id", "group"])
+lab = pd.read_parquet(OBS_LABELS, columns=["aifi_l1", "aifi_l2", "npz_row"])
+assert len(lab) == X.shape[0] and (lab.npz_row.to_numpy() == np.arange(X.shape[0])).all()
+keep = np.flatnonzero(obs.sample_id.isin(donors).to_numpy())
+LIBO = np.asarray(X @ measured.astype(np.float32)).ravel()[keep]
+MO = X[:, cols][keep].toarray().astype(np.int32)
+del X, d
+DONO = obs.sample_id.to_numpy()[keep].astype(str)
+L1O, L2O = lab.aifi_l1.to_numpy()[keep].astype(str), lab.aifi_l2.to_numpy()[keep].astype(str)
+SYM2COL = {s: i for i, s in enumerate(SYMS)}
+DIDX_O = pd.Index(donors).get_indexer(DONO)
+log(f"observed cells {len(keep):,} [{time.time() - T0:.0f}s]")
+
+
+def pmask(l1, l2, parent):
+    if parent == ["ALL"]:
+        return np.ones(len(l1), bool)
+    return np.isin(l2, parent) | np.isin(l1, parent)
+
+
+def rule(st):
+    pc = [SYM2COL[g] for g in st["genes"] if g in SYM2COL]
+    req = [[SYM2COL[g] for g in grp if g in SYM2COL] for grp in st.get("require_any", [])]
+    exc = [SYM2COL[g] for g in st.get("exclude", []) if g in SYM2COL]
+    return pc, [r for r in req if r], exc
+
+
+def call(M, st):
+    pc, req, exc = rule(st)
+    det = M > 0
+    h = det[:, pc].sum(1) >= st["k"]
+    for r in req:
+        h &= det[:, r].any(1)
+    if exc:
+        h &= ~det[:, exc].any(1)
+    return h
+
+
+def own_genes(st):
+    return set(st.get("genes", [])) | {g for grp in st.get("require_any", []) for g in grp} | set(st.get("exclude", []))
+
+
+# validate the observed loader against the screen's native per-donor counts
+bad = 0
+for st in STJ:
+    po = pmask(L1O, L2O, st["parent"])
+    ho = (np.isin(L2O, st["labels"]) & po) if st["kind"] == "label" else (call(MO, st) & po)
+    op_ = np.bincount(DIDX_O[po], minlength=n)
+    os_ = np.bincount(DIDX_O[ho], minlength=n)
+    bad += int((op_ != A[ZS, st["name"]]["obs_parent"]).sum() + (os_ != A[ZS, st["name"]]["obs_state"]).sum())
+log(f"observed loader reproduces screen native per-donor parent/state counts: mismatches = {bad}")
+
+# ------------------------------------------------------------------------------------------------ DEP
+log("== DEP: detection-matched depth ==")
+TG = np.linspace(0.0, 1.0, 401)
+PARENTS = []
+for st in STJ:
+    if st["kind"] == "markers" and st["parent"] not in PARENTS:
+        PARENTS.append(st["parent"])
+
+
+def det_curve(counts):
+    """expected detection fraction of one gene at thinning t (grid) for observed counts."""
+    vals, cnt = np.unique(counts, return_counts=True)
+    vals, cnt = vals[vals > 0], cnt[vals > 0]
+    return ((1 - (1 - TG[:, None]) ** vals[None, :]) * cnt[None, :]).sum(1) / len(counts)
+
+
+def solve_t(curve, target):
+    if target >= curve[-1]:
+        return 1.0
+    return float(np.interp(target, curve, TG))
+
+
+obs_curves = {}
+for p in PARENTS:
+    po = pmask(L1O, L2O, p)
+    obs_curves["+".join(p)] = {g: det_curve(MO[po, SYM2COL[g]]) for g in SYMS}
+rows = []
+TDET = {}
+for st in STJ:
+    if st["kind"] != "markers":
+        continue
+    p = "+".join(st["parent"])
+    curves = obs_curves[p]
+    ref = [g for g in SYMS if g not in own_genes(st) and curves[g][-1] >= 0.10]
+    for arm in ARMS:
+        gm = G[arm]
+        pg = pmask(gm["aifi_l1"].astype(str), gm["aifi_l2"].astype(str), st["parent"])
+        Mg = gm["markers"][pg]
+        tg = {g: solve_t(curves[g], float((Mg[:, SYM2COL[g]] > 0).mean())) for g in ref}
+        tv = np.array(list(tg.values()))
+        # pooled-detection version
+        gen_pool = float(np.mean([(Mg[:, SYM2COL[g]] > 0).mean() for g in ref]))
+        t_pool = solve_t(np.mean([curves[g] for g in ref], 0), gen_pool)
+        TDET[arm, st["name"]] = float(np.median(tv))
+        rows.append({"state": st["name"], "parent": p, "arm": SHORT[arm], "n_ref_genes": len(ref),
+                     "ref_genes": " ".join(ref), "t_det_median_gene": float(np.median(tv)),
+                     "t_det_q25": float(np.quantile(tv, 0.25)), "t_det_q75": float(np.quantile(tv, 0.75)),
+                     "t_det_pooled": t_pool, "n_genes_capped_at_1": int((tv >= 1.0).sum()),
+                     "screen_thin_library": THIN[arm, st["name"]],
+                     "gen_median_lib": float(np.median(gm["lib_measured"][pg])),
+                     "gen_mean_detected_of_73": float((Mg > 0).sum(1).mean())})
+DEP = pd.DataFrame(rows)
+write(DEP, "depth_detection")
+with pd.option_context("display.width", 250, "display.max_rows", 300):
+    dd = DEP.drop_duplicates(["parent", "arm"])[["parent", "arm", "n_ref_genes", "t_det_median_gene", "t_det_q25",
+                                                 "t_det_q75", "t_det_pooled", "n_genes_capped_at_1",
+                                                 "screen_thin_library", "gen_median_lib", "gen_mean_detected_of_73"]]
+    log(dd.round(3).to_string(index=False))
+    log("per-state t_det for scratch s162k vs r16 / r64 / full108k / own library thin:")
+    piv = DEP.pivot_table(index="state", columns="arm", values="t_det_median_gene")
+    piv2 = DEP.pivot_table(index="state", columns="arm", values="screen_thin_library")
+    log(pd.concat([piv[["s50k", "s162k", "r16", "r64", "full108k", "xcal", "own58"]].add_prefix("tdet_"),
+                   piv2[["r16", "r64", "full108k", "xcal", "own58"]].add_prefix("thinlib_")], axis=1).round(3)
+        .to_string())
+
+# detection-matched observed state counts per arm (one binomial draw per arm and state at t_det)
+rng_t = np.random.default_rng(SEED)
+DETCNT = {}
+for st in STJ:
+    if st["kind"] != "markers":
+        continue
+    po = pmask(L1O, L2O, st["parent"])
+    pc, req, exc = rule(st)
+    cset = sorted(set(pc) | {c for r in req for c in r} | set(exc))
+    for arm in ARMS:
+        t = TDET[arm, st["name"]]
+        Mt = MO
+        if t < 1:
+            Mt = np.zeros_like(MO)
+            Mt[:, cset] = rng_t.binomial(MO[:, cset], t)
+        h = call(Mt, st) & po
+        DETCNT[arm, st["name"]] = np.bincount(DIDX_O[h], minlength=n).astype(float)
+rows = []
+for st in RARE + CONTROLS:
+    if (L16, st) not in DETCNT:
+        continue
+    for arm in ARMS:
+        gs, gp, _, op = vecs(arm, arm, st)
+        os_ = DETCNT[arm, st]
+        pt, bs = lr("pool", gs, gp, os_, op), lr("pool", gs, gp, os_, op, W)
+        lo, hi = np.nanpercentile(bs, [2.5, 97.5])
+        rows.append({"state": st, "arm": SHORT[arm], "t_det": TDET[arm, st], "thin_library": THIN[arm, st],
+                     "obs_det_state": int(os_.sum()), "ratio_detmatched": 2 ** pt, "lo": 2 ** lo, "hi": 2 ** hi,
+                     "ratio_screen": raw_ratio(gs, gp, A[arm, st]["obsthin_state"], op)})
+DR = pd.DataFrame(rows)
+rows = []
+for scr, comp, _ in COMPS:
+    for st in RARE + CONTROLS:
+        if (L16, st) not in DETCNT:
+            continue
+        gs, gp, _, op = vecs(scr, scr, st)
+        cs, cp, _, cop = vecs(comp, comp, st)
+        a, c = DETCNT[scr, st], DETCNT[comp, st]
+        D = abs(lr("pool", gs, gp, a, op)) - abs(lr("pool", cs, cp, c, cop))
+        Db = np.abs(lr("pool", gs, gp, a, op, W)) - np.abs(lr("pool", cs, cp, c, cop, W))
+        lo, hi = np.nanpercentile(Db, [2.5, 97.5])
+        rows.append({"comparison": f"{SHORT[scr]} vs {SHORT[comp]}", "state": st, "D_detmatched": D, "lo": lo,
+                     "hi": hi, "verdict": verdict(lo, hi)})
+DD = pd.DataFrame(rows)
+write(DR, "detmatched_ratios")
+write(DD, "detmatched_comparisons")
+with pd.option_context("display.width", 250, "display.max_rows", 400):
+    log(DR.pivot_table(index="state", columns="arm", values="ratio_detmatched")[
+        ["s50k", "s162k", "r16", "r64", "full108k", "full20k", "xcal", "own5", "own58"]].round(3).to_string())
+    log(DD[~DD.state.isin(CONTROLS)].pivot_table(index="state", columns="comparison", values="verdict",
+                                                 aggfunc="first").to_string())
+# aggregate under detection matching (11 marker rare states + 2 label states at their screen values)
+rows = []
+for scr, comp, _ in COMPS:
+    Ds, Dbs = [], []
+    for st in RARE:
+        gs, gp, os_s, op = vecs(scr, scr, st)
+        cs, cp, os_c, cop = vecs(comp, comp, st)
+        if (L16, st) in DETCNT:
+            os_s, os_c = DETCNT[scr, st], DETCNT[comp, st]
+        Ds.append(abs(lr("pool", gs, gp, os_s, op)) - abs(lr("pool", cs, cp, os_c, cop)))
+        Dbs.append(np.abs(lr("pool", gs, gp, os_s, op, W)) - np.abs(lr("pool", cs, cp, os_c, cop, W)))
+    lo, hi = np.nanpercentile(np.vstack(Dbs).mean(0), [2.5, 97.5])
+    rows.append({"comparison": f"{SHORT[scr]} vs {SHORT[comp]}", "mean_D_detmatched": float(np.mean(Ds)),
+                 "lo": lo, "hi": hi, "verdict": verdict(lo, hi),
+                 "n_comparator_closer": int(sum(1 for x in DD[(DD.comparison == f"{SHORT[scr]} vs {SHORT[comp]}") &
+                                                            ~DD.state.isin(CONTROLS)].verdict
+                                                if x == "comparator_closer_sig")),
+                 "n_scratch_closer_markers_only": int(sum(1 for x in DD[(DD.comparison == f"{SHORT[scr]} vs {SHORT[comp]}") &
+                                                                     ~DD.state.isin(CONTROLS)].verdict
+                                                         if x == "scratch_closer_sig"))})
+DAG = pd.DataFrame(rows)
+write(DAG, "detmatched_aggregate")
+log(DAG.round(3).to_string(index=False))
+log(f"[{time.time() - T0:.0f}s]")
+
+# ------------------------------------------------------------------------------------------------ LAB
+log("== LAB: label-state marker support ==")
+cyc = [SYM2COL[g] for g in ["MKI67", "TOP2A", "TYMS", "CENPF", "UBE2C", "BIRC5"]]
+pbm = [SYM2COL[g] for g in ["JCHAIN", "MZB1", "TNFRSF17", "TXNDC5", "PRDM1", "IRF4", "IGLL5"]]
+rows = []
+
+
+def lab_rows(name, l1, l2, M, thin_t=None, rngx=None):
+    Mx = M
+    if thin_t is not None and thin_t < 1:
+        Mx = M.copy()
+        Mx[:, cyc + pbm] = rngx.binomial(M[:, cyc + pbm], thin_t)
+    T = np.isin(l1, ["T cell"]) | np.isin(l2, ["T cell"])
+    pro = np.isin(l2, ["Proliferating T cell"]) & T
+    pla = np.isin(l2, ["Plasma cell"])
+    ncyc = (Mx[:, cyc] > 0).sum(1)
+    npb = (Mx[:, pbm] > 0).sum(1)
+    return {"source": name, "T_cells": int(T.sum()), "prolif_T_labelled": int(pro.sum()),
+            "prolifT_frac_ge1_cycling_gene": float((ncyc[pro] >= 1).mean()) if pro.any() else np.nan,
+            "prolifT_frac_ge2_cycling_genes": float((ncyc[pro] >= 2).mean()) if pro.any() else np.nan,
+            "otherT_frac_ge2_cycling_genes": float((ncyc[T & ~pro] >= 2).mean()),
+            "frac_of_ge2cycling_T_labelled_prolif": float(pro[T & (ncyc >= 2)].mean()) if (T & (ncyc >= 2)).any() else np.nan,
+            "plasma_labelled": int(pla.sum()),
+            "plasma_frac_ge3_pb_markers": float((npb[pla] >= 3).mean()) if pla.any() else np.nan,
+            "plasma_frac_JCHAIN_or_MZB1": float(((Mx[pla][:, [SYM2COL['JCHAIN'], SYM2COL['MZB1']]] > 0).any(1)).mean())
+            if pla.any() else np.nan}
+
+
+rows.append(lab_rows("observed native", L1O, L2O, MO))
+rr = np.random.default_rng(SEED)
+for tname, tt in [("observed thinned to r16 T depth", THIN[L16, "Cycling T/NK"])]:
+    rows.append(lab_rows(tname, L1O, L2O, MO, tt, rr))
+for arm in ARMS:
+    gm = G[arm]
+    rows.append(lab_rows(SHORT[arm], gm["aifi_l1"].astype(str), gm["aifi_l2"].astype(str), gm["markers"]))
+LAB = pd.DataFrame(rows)
+write(LAB, "label_validity")
+with pd.option_context("display.width", 250):
+    log(LAB.round(3).to_string(index=False))
+
+# ------------------------------------------------------------------------------------------------ depth stats
+log("== depth readouts from extracts (cross-4) ==")
+rows = []
+for arm in ARMS:
+    gm = G[arm]
+    l1, l2 = gm["aifi_l1"].astype(str), gm["aifi_l2"].astype(str)
+    for pname, par in [("Monocyte", ["Monocyte"]), ("T cell", ["T cell"])]:
+        m = pmask(l1, l2, par)
+        Mg = gm["markers"][m]
+        nz = Mg[Mg > 0]
+        rows.append({"arm": SHORT[arm], "parent": pname, "median_lib_all_cells": float(np.median(gm["lib_measured"])),
+                     "median_lib_parent": float(np.median(gm["lib_measured"][m])),
+                     "mean_detected_of_73": float((Mg > 0).sum(1).mean()),
+                     "umi_per_detected_marker": float(nz.mean()),
+                     **{f"det_{g}": float((Mg[:, SYM2COL[g]] > 0).mean()) for g in ["HLA-DRA", "NKG7", "GZMA", "CCR7"]}})
+for pname, par in [("Monocyte", ["Monocyte"]), ("T cell", ["T cell"])]:
+    m = pmask(L1O, L2O, par)
+    Mg = MO[m]
+    nz = Mg[Mg > 0]
+    rows.append({"arm": "observed native", "parent": pname, "median_lib_all_cells": float(np.median(LIBO)),
+                 "median_lib_parent": float(np.median(LIBO[m])), "mean_detected_of_73": float((Mg > 0).sum(1).mean()),
+                 "umi_per_detected_marker": float(nz.mean()),
+                 **{f"det_{g}": float((Mg[:, SYM2COL[g]] > 0).mean()) for g in ["HLA-DRA", "NKG7", "GZMA", "CCR7"]}})
+DS = pd.DataFrame(rows)
+write(DS, "depth_readouts")
+with pd.option_context("display.width", 250):
+    log(DS.round(3).to_string(index=False))
+
+# ------------------------------------------------------------------------------------------------ CON
+log("== CON: contrasts ==")
+
+
+def pctv(s, p):
+    with np.errstate(invalid="ignore", divide="ignore"):
+        return np.where(p > 0, 100 * s / np.where(p > 0, p, 1), np.nan)
+
+
+rows = []
+gidx = {name: (np.isin(groups, a), np.isin(groups, b)) for name, a, b in CONTRASTS}
+# stratified bootstrap index (within the union of contrast groups, resample donors within each group)
+rngc = np.random.default_rng(SEED)
+grp_members = {g: np.flatnonzero(groups == g) for g in np.unique(groups)}
+SB = np.zeros((B, n))
+for b in range(B):
+    for g, mem in grp_members.items():
+        pick = rngc.choice(mem, size=len(mem), replace=True)
+        SB[b] += np.bincount(pick, minlength=n)
+
+
+def diff(vals, ma, mb, w=None):
+    ok = ~np.isnan(vals)
+    v = np.where(ok, vals, 0.0)
+    if w is None:
+        return v[ma & ok].mean() - v[mb & ok].mean()
+    wa, wb = w * (ma & ok), w * (mb & ok)
+    return (wa @ v) / wa.sum(1) - (wb @ v) / wb.sum(1)
+
+
+for arm in ARMS:
+    for variant, ref in [("own_ref", arm)] + ([("r16_depth_ref", L16), ("r64_depth_ref", L64),
+                                                ("full108k_depth_ref", F108)] if arm in SCRATCH else []):
+        for st in RARE:
+            g, o = A[arm, st], A[ref, st]
+            gp_, op_ = pctv(g["gen_state"], g["gen_parent"]), pctv(o["obsthin_state"], o["obs_parent"])
+            for name, _, _ in CONTRASTS:
+                ma, mb = gidx[name]
+                od, gd = diff(op_, ma, mb), diff(gp_, ma, mb)
+                gdb, odb = diff(gp_, ma, mb, SB), diff(op_, ma, mb, SB)
+                lodo_same = 0
+                for j in range(n):
+                    keepj = np.ones(n, bool)
+                    keepj[j] = False
+                    gdj = diff(gp_, ma & keepj, mb & keepj)
+                    lodo_same += np.sign(gdj) == np.sign(od)
+                rows.append({"arm": SHORT[arm], "variant": variant, "state": st, "contrast": name,
+                             "n_a": int(ma.sum()), "n_b": int(mb.sum()), "obs_diff": od, "gen_diff": gd,
+                             "same_direction": bool(np.sign(od) == np.sign(gd)),
+                             "gen_over_obs_diff": gd / od if od != 0 else np.nan,
+                             "boot_P_gen_sign_eq_obs": float(np.mean(np.sign(gdb) == np.sign(od))),
+                             "boot_P_obs_sign_stable": float(np.mean(np.sign(odb) == np.sign(od))),
+                             "lodo_same_direction_frac": lodo_same / n,
+                             "obs_state_cells_group_b": int(o["obsthin_state"][mb].sum()),
+                             "gen_state_cells_group_a": int(g["gen_state"][ma].sum()),
+                             "gen_state_cells_group_b": int(g["gen_state"][mb].sum())})
+CT = pd.DataFrame(rows)
+own = CT[CT.variant == "own_ref"]
+elig = own.assign(big=own.obs_diff.abs() >= 0.5, sg=np.sign(own.obs_diff)).groupby(["state", "contrast"]).agg(
+    big=("big", "all"), sgn=("sg", lambda s: s.nunique() == 1)).reset_index()
+elig["common"] = elig.big & elig.sgn
+CT = CT.merge(elig[["state", "contrast", "common"]], on=["state", "contrast"], how="left")
+write(CT, "contrasts")
+rows = []
+for (arm, variant), t in CT[CT.common].groupby(["arm", "variant"], sort=False):
+    k = int(t.same_direction.sum())
+    rows.append({"arm": arm, "variant": variant, "n_pairs": len(t), "kept": k,
+                 "binom_p_ge_kept_at_0.5": float(binom.sf(k - 1, len(t), 0.5)),
+                 "robust_kept_boot_P>=0.95": int((t.boot_P_gen_sign_eq_obs >= 0.95).sum()),
+                 "robust_reversed_boot_P<=0.05": int((t.boot_P_gen_sign_eq_obs <= 0.05).sum()),
+                 "kept_and_lodo_stable": int((t.same_direction & (t.lodo_same_direction_frac == 1)).sum()),
+                 "median_ratio_kept": float(t[t.same_direction].gen_over_obs_diff.median()),
+                 "median_ratio_all21_signed": float(t.gen_over_obs_diff.median()),
+                 "mean_ratio_all21_signed": float(t.gen_over_obs_diff.mean())})
+CC = pd.DataFrame(rows)
+write(CC, "contrast_counts")
+with pd.option_context("display.width", 250):
+    log(CC.round(3).to_string(index=False))
+# paired compression on pairs kept by both (own reference)
+rows = []
+for comp in [L16, L64, F108, F20, XCAL, OWN58]:
+    a = CT[(CT.arm == "s162k") & (CT.variant == "own_ref") & CT.common].set_index(["state", "contrast"])
+    a16 = CT[(CT.arm == "s162k") & (CT.variant == "r16_depth_ref") & CT.common].set_index(["state", "contrast"])
+    c = CT[(CT.arm == SHORT[comp]) & (CT.variant == "own_ref") & CT.common].set_index(["state", "contrast"])
+    both = a.same_direction & c.same_direction
+    rows.append({"comparator": SHORT[comp], "pairs_kept_by_both": int(both.sum()),
+                 "scratch_median_ratio_on_both": float(a[both].gen_over_obs_diff.median()),
+                 "scratch_r16depth_median_ratio_on_both": float(a16[both].gen_over_obs_diff.median()),
+                 "comparator_median_ratio_on_both": float(c[both].gen_over_obs_diff.median()),
+                 "pairs_scratch_less_compressed": int((a[both].gen_over_obs_diff > c[both].gen_over_obs_diff).sum())})
+PC = pd.DataFrame(rows)
+write(PC, "contrast_paired_compression")
+log(PC.round(3).to_string(index=False))
+log(f"[{time.time() - T0:.0f}s]")
+
+# ------------------------------------------------------------------------------------------------ SP
+log("== SP: Spearman over donors ==")
+
+
+def spearman(x, y):
+    ok = ~(np.isnan(x) | np.isnan(y))
+    x, y = x[ok], y[ok]
+    if len(x) < 3:
+        return np.nan
+    rx, ry = rankdata(x), rankdata(y)
+    if rx.std() == 0 or ry.std() == 0:
+        return np.nan
+    return float(np.corrcoef(rx, ry)[0, 1])
+
+
+def sp_boot(x, y):
+    out = np.full(B, np.nan)
+    for b in range(B):
+        out[b] = spearman(x[IDX[b]], y[IDX[b]])
+    return out
+
+
+rows, SPB = [], {}
+for arm in ARMS:
+    for st in RARE:
+        g = A[arm, st]
+        x, y = pctv(g["gen_state"], g["gen_parent"]), pctv(g["obsthin_state"], g["obs_parent"])
+        SPB[arm, st] = sp_boot(x, y)
+        rows.append({"arm": SHORT[arm], "state": st, "rho": spearman(x, y),
+                     "rho_lo": np.nanpercentile(SPB[arm, st], 2.5), "rho_hi": np.nanpercentile(SPB[arm, st], 97.5),
+                     "frac_donors_gen_state_0": float(np.mean(g["gen_state"] == 0)),
+                     "frac_donors_obs_state_0": float(np.mean(g["obsthin_state"] == 0))})
+SPT = pd.DataFrame(rows)
+rows = []
+for comp in [L16, L64, F108, XCAL, OWN58]:
+    for st in RARE:
+        dlt = SPB[S162, st] - SPB[comp, st]
+        lo, hi = np.nanpercentile(dlt, [2.5, 97.5])
+        rows.append({"comparison": f"s162k vs {SHORT[comp]}", "state": st,
+                     "diff": SPT[(SPT.arm == "s162k") & (SPT.state == st)].rho.iloc[0]
+                     - SPT[(SPT.arm == SHORT[comp]) & (SPT.state == st)].rho.iloc[0],
+                     "lo": lo, "hi": hi, "ci_width": hi - lo,
+                     "verdict": "scratch_higher_sig" if lo > 0 else "comparator_higher_sig" if hi < 0 else "n.s."})
+SPD = pd.DataFrame(rows)
+write(SPT, "spearman")
+write(SPD, "spearman_diff")
+with pd.option_context("display.width", 250, "display.max_rows", 300):
+    pv = SPT.pivot_table(index="state", columns="arm", values="rho")[[SHORT[a] for a in ARMS]]
+    log(pv.round(3).to_string())
+    log("mean rho over 13 states: " + ", ".join(f"{k} {v:.3f}" for k, v in pv.mean().items()))
+    log("best arm per state: " + "; ".join(f"{s[:18]}={pv.loc[s].idxmax()}" for s in pv.index))
+    log(SPD.groupby("comparison").agg(n_sig=("verdict", lambda v: int((v != "n.s.").sum())),
+                                      median_ci_width=("ci_width", "median"), mean_diff=("diff", "mean")).round(3)
+        .to_string())
+    log(SPD[SPD.verdict != "n.s."].round(3).to_string(index=False))
+
+# ------------------------------------------------------------------------------------------------ FOLD
+log("== FOLD: own-cohort vs cross-cohort arms on each within-cohort fold's donors ==")
+folds = pd.read_csv(DATA / "folds.csv").set_index("sample_id").fold.reindex(donors).to_numpy()
+rows = []
+for st in ["C1Q-high monocyte (reference)", "MS1 monocyte (IL1R2+)", "Cycling T/NK", "Cycling monocyte (Ye 2026)"]:
+    for arm in [OWN5, OWN58, S162, L16, L64, F108, XCAL]:
+        for f in sorted(set(folds)):
+            m = folds == f
+            gs, gp, os_, op = (v[m] for v in vecs(arm, arm, st))
+            rows.append({"state": st, "arm": SHORT[arm], "fold": int(f), "n_donors": int(m.sum()),
+                         "ratio": raw_ratio(gs, gp, os_, op), "gen_state": int(gs.sum()),
+                         "obsthin_state": int(os_.sum())})
+FO = pd.DataFrame(rows)
+write(FO, "per_fold")
+with pd.option_context("display.width", 250, "display.max_rows", 300):
+    log(FO.pivot_table(index=["state", "fold"], columns="arm", values="ratio")[
+        ["own5", "own58", "s162k", "r16", "r64", "full108k", "xcal"]].round(3).to_string())
+
+(OUT / f"{PFX}run.log").write_text("\n".join(LOG) + "\n")
+log(f"done [{time.time() - T0:.0f}s]")

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_confound_within_analysis.py

@@ -0,0 +1,965 @@
+#!/usr/bin/env python3
+"""Adversarial confound verification of the WITHIN-COHORT scratch-vs-pretrained rare-state claims (within-1..8).
+
+CPU only, read-only inputs, 2026-10-05.  Run:
+    CUDA_VISIBLE_DEVICES='' PYTHONDONTWRITEBYTECODE=1 OMP_NUM_THREADS=4 \
+        /home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python verify_confound_within_analysis.py
+Writes only verify_confound_within_*.csv next to this script (NaN / undefined -> "null").
+
+Inputs (read-only)
+  ../sepsis_fold0_{per_donor,summary,contrasts}.csv       fold 0, 17 held-out donors, 8 arms
+  ../sepsis_per_donor.csv                                  pooled cross-fitted arms (all 82 donors; LoRA n5..n40, all)
+  ../../work/sepsis/fold0/<arm>.npz                        per-cell marker extracts of the generated cells
+  tools/sepsis_states.observed()                           observed cells of the same 17 donors (imported, not run)
+  paired_finetune_intradataset_20260927/data/ye2026_sepsis/folds.csv   fold assignment
+
+Sections (output file suffix)
+  repro           re-computation of every number used by the claims (pooled ratio, |log2|, D, percentile / BC CI)
+  lodo            leave-one-donor-out D (point + 16-donor bootstrap verdict) for all comparisons, states, aggregates
+  donormean       donor-mean weighting (mean per-donor %) instead of pooled cell counts
+  concentration   observed state cells: donors carrying the state, top-donor share, sepsis share
+  depth           re-scoring of marker states from the per-cell extracts under alternative depth handling:
+                    V0_replay        exact replay of the screen (seed 20261004)  -> validates this pipeline
+                    V0_reseed        screen thinning constants, new binomial draw (seed 20261005)
+                    V1_lib_trained   generated AND observed thinned to one common library target per state
+                                     (lowest parent median among observed + 7 trained arms)
+                    V1_lib_all       same, target includes zero-shot (lowest)
+                    V2_msum_trained  common target on effective marker depth (sum of parent mean counts over the
+                                     extracted markers minus the state's own rule genes, observed mean >= 0.1)
+                    V2_msum_all      same, incl. zero-shot
+  composition     parent-composition standardisation (rates within AIFI L2 strata re-weighted to observed mix)
+  labelcheck      proliferating-T label vs cycling-marker rule with donor-bootstrap CIs
+  contrasts       direction counts, LODO stability, paired discordance, relative reversal strength
+  spearman        Spearman reproduction, perfect-tracking noise ceiling, within-sepsis-only Spearman
+  folds           LoRA arms of other folds / other pair counts (pooled cross-fitted CSV) -> generalisation
+"""
+from __future__ import annotations
+
+import json
+import sys
+import time
+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/scratch_vs_lora_20261005"
+SRC = PLAN / "out"
+WORK = PLAN / "work/sepsis/fold0"
+FOLDS = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+             "paired_finetune_intradataset_20260927/data/ye2026_sepsis/folds.csv")
+PREFIX = "verify_confound_within_"
+sys.path.insert(0, str(PLAN / "tools"))
+from screen import call_state, parent_mask, state_cols  # noqa: E402
+from sepsis_states import observed  # noqa: E402
+
+SEED, NBOOT, PC = 20261005, 2000, 0.5
+SCREEN_THIN_SEED = 20261004
+ARMS = ["zs__raw", "lora_n5__raw", "scratch_n5__raw", "real_lora__raw", "real_full__raw", "scratch_full__raw",
+        "lora_recipe__raw", "scratch_recipe__raw"]
+TRAINED = ARMS[1:]
+MAIN = [("5 pairs: scratch vs LoRA", "scratch_n5__raw", "lora_n5__raw"),
+        ("58 pairs: scratch vs LoRA", "scratch_full__raw", "real_lora__raw"),
+        ("58 pairs: scratch vs full FT", "scratch_full__raw", "real_full__raw"),
+        ("58 pairs + recipes: scratch vs LoRA", "scratch_recipe__raw", "lora_recipe__raw")]
+REFC = [("ref: scratch 5 pairs vs zero-shot", "scratch_n5__raw", "zs__raw"),
+        ("ref: scratch 58 pairs vs zero-shot", "scratch_full__raw", "zs__raw"),
+        ("ref: scratch 58 + recipes vs zero-shot", "scratch_recipe__raw", "zs__raw")]
+CONTROLS = ["ISG-high monocyte (positive control)", "Platelet signal in monocytes (negative control)"]
+LABEL_STATES = ["Proliferating T (label)", "Plasmablast (label)"]
+KEYS = ["gen_state", "gen_parent", "obsthin_state", "obs_parent", "obs_state", "gen_pct", "obsthin_pct"]
+CYC = ["MKI67", "TOP2A", "TYMS", "CENPF", "UBE2C", "BIRC5"]
+T0 = time.time()
+
+
+def log(*a):
+    print(f"[{time.time() - T0:7.1f}s]", *a, flush=True)
+
+
+def write(df: pd.DataFrame, name: str) -> None:
+    df.to_csv(OUT / f"{PREFIX}{name}.csv", index=False, na_rep="null", float_format="%.6g")
+    log("wrote", f"{PREFIX}{name}.csv", df.shape)
+
+
+# ----------------------------------------------------------------------------------------------- statistics helpers
+def l2r(x: dict, sub=None, idx=None, pc=PC):
+    """Pooled log2((gen_state+pc)/gen_parent / ((obsthin_state+pc)/obs_parent)); sub = donor subset (positions),
+    idx = bootstrap index matrix into that subset (B, n_sub) -> (B,)."""
+    def tot(k):
+        v = x[k] if sub is None else x[k][sub]
+        return v.sum() if idx is None else v[idx].sum(-1)
+    gs, gp, os_, op = tot("gen_state"), tot("gen_parent"), tot("obsthin_state"), tot("obs_parent")
+    with np.errstate(divide="ignore", invalid="ignore"):
+        v = np.log2(((gs + pc) / gp) / ((os_ + pc) / op))
+    return np.where(np.isfinite(v), v, np.nan)
+
+
+def raw_ratio(x: dict, sub=None):
+    s = (lambda k: x[k].sum()) if sub is None else (lambda k: x[k][sub].sum())
+    gp, op, os_ = s("gen_parent"), s("obs_parent"), s("obsthin_state")
+    if gp == 0 or op == 0 or os_ == 0:
+        return np.nan
+    return (s("gen_state") / gp) / (os_ / op)
+
+
+def pci(v):
+    v = np.asarray(v, float)
+    v = v[np.isfinite(v)]
+    if len(v) == 0:
+        return np.nan, np.nan
+    lo, hi = np.percentile(v, [2.5, 97.5])
+    return float(lo), float(hi)
+
+
+def bc_ci(v, t0):
+    v = np.asarray(v, float)
+    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 float(lo), float(hi)
+
+
+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 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 spearman_rows(G, O):
+    """Row-wise Spearman of (B, n) arrays; rows with NaN fall back to the masked scalar version."""
+    out = np.full(G.shape[0], np.nan)
+    bad = ~(np.isfinite(G).all(1) & np.isfinite(O).all(1))
+    ok = ~bad
+    if ok.any():
+        rg, ro = rankdata(G[ok], axis=1), rankdata(O[ok], axis=1)
+        rg = rg - rg.mean(1, keepdims=True)
+        ro = 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[ok] = np.where(den > 0, (rg * ro).sum(1) / den, np.nan)
+    for i in np.flatnonzero(bad):
+        out[i] = spearman(G[i], O[i])
+    return out
+
+
+def absl(v):
+    return np.abs(v)
+
+
+# ----------------------------------------------------------------------------------------------- load
+def load_fold0():
+    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")
+    donors = sorted(P.donor.unique())
+    states = list(dict.fromkeys(S.state))
+    A = {}
+    for (a, s), t in P.groupby(["arm", "state"]):
+        t = t.set_index("donor").loc[donors]
+        A[a, s] = {k: t[k].to_numpy(float) for k in KEYS}
+    groups = P.drop_duplicates("donor").set_index("donor").group.loc[donors].to_numpy()
+    return P, S, C, donors, states, A, groups
+
+
+def comparison_rows(A, states, rare, comps, IDX, tag, extra=None):
+    """D = |log2 r_pc(scratch)| - |log2 r_pc(pretrained)| per state + aggregate over `rare`, donor bootstrap."""
+    rows = []
+    L0 = {}
+    LB = {}
+    arms = {a for _, sa, pa in comps for a in (sa, pa)}
+    for a in arms:
+        for s in states:
+            L0[a, s] = float(l2r(A[a, s]))
+            LB[a, s] = l2r(A[a, s], idx=IDX)
+    for name, sa, pa in comps:
+        for s in states + ["AGGREGATE"]:
+            if s == "AGGREGATE":
+                ss = rare
+                d0 = float(np.mean([abs(L0[sa, t]) - abs(L0[pa, t]) for t in ss]))
+                db = np.mean(np.vstack([absl(LB[sa, t]) - absl(LB[pa, t]) for t in ss]), axis=0)
+                fs = float(np.mean([abs(L0[sa, t]) for t in ss]))
+                fp = float(np.mean([abs(L0[pa, t]) for t in ss]))
+                rs = rp = np.nan
+            else:
+                d0 = abs(L0[sa, s]) - abs(L0[pa, s])
+                db = absl(LB[sa, s]) - absl(LB[pa, s])
+                fs, fp = abs(L0[sa, s]), abs(L0[pa, s])
+                rs, rp = raw_ratio(A[sa, s]), raw_ratio(A[pa, s])
+            lo, hi = pci(db)
+            blo, bhi = bc_ci(db, d0)
+            row = {"scheme": tag, "comparison": name, "scratch_arm": sa, "pretrained_arm": pa, "state": s,
+                   "ratio_scratch": rs, "ratio_pretrained": rp, "abs_log2_scratch": fs, "abs_log2_pretrained": fp,
+                   "D": d0, "D_ci_lo": lo, "D_ci_hi": hi, "verdict": verdict(lo, hi),
+                   "D_bc_ci_lo": blo, "D_bc_ci_hi": bhi, "verdict_bc": verdict(blo, bhi)}
+            if extra:
+                row.update(extra.get((sa, pa, s), {}))
+            rows.append(row)
+    return pd.DataFrame(rows), L0, LB
+
+
+# ----------------------------------------------------------------------------------------------- main
+def main():
+    P, S, C, donors, states, A, groups = load_fold0()
+    n = len(donors)
+    rare = [s for s in states if s not in CONTROLS]
+    marker_states = [s for s in states if s not in LABEL_STATES]
+    IDX = np.random.default_rng(SEED).integers(0, n, (NBOOT, n))
+    log("donors", n, dict(pd.Series(groups).value_counts()), "rare states", len(rare))
+
+    # ===================================================================================== 1. reproduction
+    R, L0, LB = comparison_rows(A, states, rare, MAIN + REFC, IDX, "V0_published")
+    pub = pd.read_csv(OUT / "within_bootstrap.csv")
+    pub["state2"] = np.where(pub.role == "aggregate", "AGGREGATE", pub.state)
+    m = R.merge(pub[["scratch_arm", "pretrained_arm", "state2", "D", "D_ci_lo", "D_ci_hi", "D_bc_ci_lo",
+                     "D_bc_ci_hi"]].rename(columns={"state2": "state"}),
+                on=["scratch_arm", "pretrained_arm", "state"], suffixes=("", "_pub"))
+    for c in ["D", "D_ci_lo", "D_ci_hi", "D_bc_ci_lo", "D_bc_ci_hi"]:
+        m[f"absdiff_{c}"] = (m[c] - m[f"{c}_pub"]).abs()
+    R = m
+    # arm-level fidelity (signed log2 with CI) and mean |log2| per arm
+    af = []
+    for a in ARMS:
+        for s in states:
+            lo, hi = pci(LB.get((a, s), l2r(A[a, s], idx=IDX)))
+            af.append({"arm": a, "state": s, "ratio_raw": raw_ratio(A[a, s]), "log2_pc": float(l2r(A[a, s])),
+                       "log2_ci_lo": lo, "log2_ci_hi": hi, "gen_state": A[a, s]["gen_state"].sum(),
+                       "gen_parent": A[a, s]["gen_parent"].sum(), "obsthin_state": A[a, s]["obsthin_state"].sum(),
+                       "obs_parent": A[a, s]["obs_parent"].sum()})
+        af.append({"arm": a, "state": "MEAN |log2| over 13 rare states",
+                   "log2_pc": float(np.mean([abs(float(l2r(A[a, s]))) for s in rare]))})
+    AF = pd.DataFrame(af)
+    R2 = pd.concat([R.assign(section="comparison"), AF.assign(section="arm")], ignore_index=True)
+    write(R2, "repro")
+    log("max |diff| vs published:", {c: float(R[f'absdiff_{c}'].max()) for c in ["D", "D_ci_lo", "D_ci_hi",
+                                                                                   "D_bc_ci_lo", "D_bc_ci_hi"]})
+    main_rows = R[R.comparison.isin([c[0] for c in MAIN]) & R.state.isin(rare)]
+    log("state-level verdict counts (main, 13 rare):", main_rows.verdict.value_counts().to_dict(),
+        "BC:", main_rows.verdict_bc.value_counts().to_dict())
+
+    # state-set sensitivity of the aggregate
+    subsets = {
+        "13 rare (claim)": rare,
+        "11 marker states (no label states)": [s for s in rare if s not in LABEL_STATES],
+        "drop states where both arms < 0.25x": None,  # per comparison
+        "drop LDG + cycling monocyte (dual failures)": [s for s in rare if s not in
+                                                        ("Granulocyte-like (LDG)", "Cycling monocyte (Ye 2026)")],
+        "non-redundant 9 (drop Cycling activated T, Plasmablast markers, Proliferating T label, HSPC)":
+            [s for s in rare if s not in ("Cycling activated T (CD38/HLA-DR)", "Plasmablast (markers)",
+                                          "Proliferating T (label)", "HSPC")],
+        "monocyte states (C1Q, MS1, cycling mono)": ["C1Q-high monocyte (reference)", "MS1 monocyte (IL1R2+)",
+                                                     "Cycling monocyte (Ye 2026)"],
+        "T/NK states (cycling T/NK, cycling act T, prolif T label, ISG-high T, cytotoxic CD4)":
+            ["Cycling T/NK", "Cycling activated T (CD38/HLA-DR)", "Proliferating T (label)", "ISG-high T",
+             "Cytotoxic CD4 T"],
+    }
+    ssr = []
+    for name, sa, pa in MAIN + REFC:
+        for lab, ss in subsets.items():
+            if ss is None:
+                ss = [s for s in rare if not (raw_ratio(A[sa, s]) < 0.25 and raw_ratio(A[pa, s]) < 0.25)]
+            d0 = float(np.mean([abs(L0[sa, t]) - abs(L0[pa, t]) for t in ss]))
+            db = np.mean(np.vstack([absl(LB[sa, t]) - absl(LB[pa, t]) for t in ss]), axis=0)
+            lo, hi = pci(db)
+            blo, bhi = bc_ci(db, d0)
+            ssr.append({"comparison": name, "state_set": lab, "n_states": len(ss), "D": d0, "D_ci_lo": lo,
+                        "D_ci_hi": hi, "verdict": verdict(lo, hi), "D_bc_ci_lo": blo, "D_bc_ci_hi": bhi,
+                        "verdict_bc": verdict(blo, bhi), "states": "; ".join(ss)})
+    write(pd.DataFrame(ssr), "stateset")
+
+    # ===================================================================================== 2. leave-one-donor-out
+    IDX16 = np.random.default_rng(SEED).integers(0, n - 1, (NBOOT, n - 1))
+    lodo = []
+    full = {(r.comparison, r.state): r for r in R.itertuples()}
+    for name, sa, pa in MAIN + REFC:
+        per = {s: [] for s in states + ["AGGREGATE"]}
+        for j in range(n):
+            sub = np.delete(np.arange(n), j)
+            sidx = sub[IDX16]
+            Ls = {(a, s): float(l2r(A[a, s], sub=sub)) for a in (sa, pa) for s in states}
+            Lb = {(a, s): l2r(A[a, s], idx=sidx) for a in (sa, pa) for s in states}
+            for s in states + ["AGGREGATE"]:
+                if s == "AGGREGATE":
+                    d0 = float(np.mean([abs(Ls[sa, t]) - abs(Ls[pa, t]) for t in rare]))
+                    db = np.mean(np.vstack([absl(Lb[sa, t]) - absl(Lb[pa, t]) for t in rare]), axis=0)
+                else:
+                    d0 = abs(Ls[sa, s]) - abs(Ls[pa, s])
+                    db = absl(Lb[sa, s]) - absl(Lb[pa, s])
+                lo, hi = pci(db)
+                blo, bhi = bc_ci(db, d0)
+                per[s].append((donors[j], d0, verdict(lo, hi), verdict(blo, bhi),
+                               2 ** Ls[sa, s] if s != "AGGREGATE" else np.nan,
+                               2 ** Ls[pa, s] if s != "AGGREGATE" else np.nan))
+        for s, v in per.items():
+            f = full[(name, s)]
+            ds = np.array([x[1] for x in v])
+            vs = [x[2] for x in v]
+            vb = [x[3] for x in v]
+            infl = int(np.argmax(np.abs(ds - f.D)))
+            lodo.append({"comparison": name, "state": s, "D_full": f.D, "verdict_full": f.verdict,
+                         "verdict_bc_full": f.verdict_bc, "D_lodo_min": ds.min(), "D_lodo_max": ds.max(),
+                         "n_lodo_sign_flip": int((np.sign(ds) != np.sign(f.D)).sum()),
+                         "n_lodo_same_verdict": int(sum(x == f.verdict for x in vs)),
+                         "n_lodo_same_verdict_bc": int(sum(x == f.verdict_bc for x in vb)),
+                         "lodo_verdicts": "; ".join(f"{k}:{vs.count(k)}" for k in sorted(set(vs))),
+                         "lodo_verdicts_bc": "; ".join(f"{k}:{vb.count(k)}" for k in sorted(set(vb))),
+                         "most_influential_donor": v[infl][0], "D_without_it": ds[infl],
+                         "ratio_scratch_without_it": v[infl][4], "ratio_pretrained_without_it": v[infl][5]})
+    LO = pd.DataFrame(lodo)
+    write(LO, "lodo")
+
+    # ===================================================================================== 3. donor-mean weighting
+    dm = []
+    for name, sa, pa in MAIN + REFC:
+        Dsb, Ds0 = [], []
+        for s in states:
+            xs, xp = A[sa, s], A[pa, s]
+            mask = (np.isfinite(xs["gen_pct"]) & np.isfinite(xp["gen_pct"]) & np.isfinite(xs["obsthin_pct"])
+                    & np.isfinite(xp["obsthin_pct"]))
+
+            def rdm(x, idx=None):
+                w = mask.astype(float) if idx is None else mask[idx].astype(float)
+                g = np.nan_to_num(x["gen_pct"]) if idx is None else np.nan_to_num(x["gen_pct"])[idx]
+                o = np.nan_to_num(x["obsthin_pct"]) if idx is None else np.nan_to_num(x["obsthin_pct"])[idx]
+                with np.errstate(divide="ignore", invalid="ignore"):
+                    r = (g * w).sum(-1) / (o * w).sum(-1)
+                    v = np.log2(r)
+                return np.where(np.isfinite(v), v, np.nan)
+            ls, lp = float(rdm(xs)), float(rdm(xp))
+            bs, bp = rdm(xs, IDX), rdm(xp, IDX)
+            d0 = abs(ls) - abs(lp) if np.isfinite(ls) and np.isfinite(lp) else np.nan
+            db = np.abs(bs) - np.abs(bp)
+            lo, hi = pci(db)
+            if s in rare:
+                Ds0.append(d0)
+                Dsb.append(db)
+            dm.append({"comparison": name, "state": s, "n_donors": int(mask.sum()),
+                       "ratio_donor_mean_scratch": 2 ** ls if np.isfinite(ls) else np.nan,
+                       "ratio_donor_mean_pretrained": 2 ** lp if np.isfinite(lp) else np.nan,
+                       "ratio_pooled_scratch": raw_ratio(xs), "ratio_pooled_pretrained": raw_ratio(xp),
+                       "D_donor_mean": d0, "D_ci_lo": lo, "D_ci_hi": hi, "verdict": verdict(lo, hi),
+                       "D_pooled_pc": full[(name, s)].D, "verdict_pooled": full[(name, s)].verdict})
+        d0 = float(np.mean(Ds0)) if np.all(np.isfinite(Ds0)) else np.nan
+        db = np.nanmean(np.vstack(Dsb), axis=0)
+        lo, hi = pci(db)
+        dm.append({"comparison": name, "state": "AGGREGATE", "D_donor_mean": d0, "D_ci_lo": lo, "D_ci_hi": hi,
+                   "verdict": verdict(lo, hi), "D_pooled_pc": full[(name, 'AGGREGATE')].D,
+                   "verdict_pooled": full[(name, 'AGGREGATE')].verdict})
+    write(pd.DataFrame(dm), "donormean")
+
+    # ===================================================================================== 4. observed concentration
+    con = []
+    sepsis = np.isin(groups, ["adult_sepsis", "ped_sepsis"])
+    for s in states:
+        x = A[ARMS[1], s]
+        nat = x["obs_state"]
+        th = {a: A[a, s]["obsthin_state"] for a in ARMS}
+        order = np.argsort(-nat)
+        row = {"state": s, "obs_native_state_cells": nat.sum(), "obs_parent_cells": x["obs_parent"].sum(),
+               "donors_with_state": int((nat > 0).sum()), "top_donor": donors[order[0]],
+               "top_donor_group": groups[order[0]], "top_donor_share": nat[order[0]] / nat.sum() if nat.sum() else np.nan,
+               "top2_share": nat[order[:2]].sum() / nat.sum() if nat.sum() else np.nan,
+               "sepsis_share_of_state_cells": nat[sepsis].sum() / nat.sum() if nat.sum() else np.nan,
+               "sepsis_share_of_parent_cells": x["obs_parent"][sepsis].sum() / x["obs_parent"].sum(),
+               "obsthin_state_min_over_arms": min(v.sum() for v in th.values()),
+               "obsthin_state_max_over_arms": max(v.sum() for v in th.values())}
+        for a in ARMS:
+            g = A[a, s]["gen_state"]
+            row[f"gen_state__{a}"] = g.sum()
+            row[f"gen_top_donor_share__{a}"] = g.max() / g.sum() if g.sum() else np.nan
+        con.append(row)
+    write(pd.DataFrame(con), "concentration")
+
+    # ===================================================================================== 5. depth re-scoring
+    st_json = json.loads((PLAN / "tools/states.json").read_text())
+    st_by = {st["name"]: st for st in st_json}
+    log("loading observed cells via tools/sepsis_states.observed() ...")
+    ob = observed(st_json, donors)
+    syms = list(ob["marker_symbols"])
+    dcode = {d: i for i, d in enumerate(donors)}
+    do = np.array([dcode[d] for d in ob["donor"]])
+    lab_o = ob["lab"]
+    Mo, libo = ob["markers"], ob["lib"]
+    log("observed cells", Mo.shape)
+    G = {}
+    for a in ARMS:
+        g = np.load(WORK / f"{a}.npz", allow_pickle=False)
+        if list(g["marker_symbols"].astype(str)) != syms:
+            raise SystemExit(f"{a}: marker columns differ")
+        G[a] = {"M": g["markers"], "lib": g["lib_measured"].astype(float),
+                "d": np.array([dcode[x] for x in g["donor"].astype(str)]),
+                "lab": pd.DataFrame({"aifi_l1": g["aifi_l1"].astype(str), "aifi_l2": g["aifi_l2"].astype(str)})}
+    sym2col = {s: i for i, s in enumerate(syms)}
+    ident = {s: s for s in syms}
+
+    def parts(st):
+        _, pcols, req, exc = state_cols(st, ident, sym2col)
+        cols = pcols + [x for r in req for x in r] + exc
+        rule = set(st.get("genes", [])) | {x for gg in st.get("require_any", []) for x in gg} | set(st.get("exclude", []))
+        return cols, len(pcols), req, exc, rule
+
+    def bc(codes, mask):
+        return np.bincount(codes[mask], minlength=n).astype(float)
+
+    # 5a. exact replay of the screen's RNG sequence (validates every per-donor count of the published CSV)
+    rng = np.random.default_rng(SCREEN_THIN_SEED)
+    replay_bad = 0
+    for a in ARMS:
+        for st in st_json:
+            po = parent_mask(lab_o, st["parent"])
+            pg = parent_mask(G[a]["lab"], st["parent"])
+            if st["kind"] == "label":
+                hg = G[a]["lab"].aifi_l2.isin(st["labels"]).to_numpy() & pg
+                ht = lab_o.aifi_l2.isin(st["labels"]).to_numpy() & po
+            else:
+                cols, npos, req, exc, _ = parts(st)
+                thin = min(1.0, float(np.median(G[a]["lib"][pg])) / float(np.median(libo[po])))
+                co = Mo[:, cols].astype(np.int64)
+                ct = rng.binomial(co, thin) if thin < 1.0 else co
+                ht = call_state(ct, st, npos, req, exc) & po
+                hg = call_state(G[a]["M"][:, cols], st, npos, req, exc) & pg
+            x = A[a, st["name"]]
+            ok = (np.array_equal(bc(do, ht), x["obsthin_state"]) and np.array_equal(bc(G[a]["d"], hg), x["gen_state"])
+                  and np.array_equal(bc(do, po), x["obs_parent"]) and np.array_equal(bc(G[a]["d"], pg), x["gen_parent"]))
+            replay_bad += int(not ok)
+    log("V0 replay: per-donor count rows not reproduced (arm x state):", replay_bad, "of", len(ARMS) * len(st_json))
+
+    # 5b. alternative depth schemes
+    def depth_meas(st):
+        po = parent_mask(lab_o, st["parent"])
+        cols, npos, req, exc, rule = parts(st)
+        mo_mean = Mo[po].mean(0)
+        ref = [i for i, s_ in enumerate(syms) if s_ not in rule and mo_mean[i] >= 0.1]
+        e = {"OBS": (float(np.median(libo[po])), float(mo_mean[ref].sum()))}
+        for a in ARMS:
+            pg = parent_mask(G[a]["lab"], st["parent"])
+            e[a] = (float(np.median(G[a]["lib"][pg])), float(G[a]["M"][pg][:, ref].mean(0).sum()))
+        return e, len(ref)
+
+    schemes = ["V0_reseed", "V1_lib_trained", "V1_lib_all", "V2_msum_trained", "V2_msum_all"]
+    Asch = {sc: {} for sc in schemes}
+    depth_rows = []
+    calls_v0 = {}  # (arm, state) -> (obs thinned calls, gen calls) for the composition section
+    Sx = S.set_index(["arm", "state"])
+    for sc in schemes:
+        rng = np.random.default_rng(SEED)
+        for st in st_json:
+            sname = st["name"]
+            if st["kind"] == "label":
+                for a in ARMS:
+                    Asch[sc][a, sname] = A[a, sname]
+                continue
+            cols, npos, req, exc, _ = parts(st)
+            po = parent_mask(lab_o, st["parent"])
+            co = Mo[:, cols].astype(np.int64)
+            e, nref = depth_meas(st)
+            k = 0 if sc.startswith("V1") else 1
+            pool = TRAINED if sc.endswith("trained") else ARMS
+            if sc != "V0_reseed":
+                target = min([e["OBS"][k]] + [e[a][k] for a in pool])
+                thin_o = target / e["OBS"][k]
+                ct = rng.binomial(co, thin_o) if thin_o < 1 else co
+                ht_common = call_state(ct, st, npos, req, exc) & po
+            for a in ARMS:
+                pg = parent_mask(G[a]["lab"], st["parent"])
+                if sc == "V0_reseed":
+                    thin_o = min(1.0, e[a][0] / e["OBS"][0])
+                    ct = rng.binomial(co, thin_o) if thin_o < 1 else co
+                    ht = call_state(ct, st, npos, req, exc) & po
+                    thin_g = 1.0
+                    gm = G[a]["M"][:, cols]
+                else:
+                    ht = ht_common
+                    thin_g = min(1.0, target / e[a][k])
+                    gm = G[a]["M"][:, cols].astype(np.int64)
+                    gm = rng.binomial(gm, thin_g) if thin_g < 1 else gm
+                hg = call_state(gm, st, npos, req, exc) & pg
+                if sc == "V0_reseed":
+                    calls_v0[a, sname] = (ht, hg)
+                op, gp = bc(do, po), bc(G[a]["d"], pg)
+                os_, gs = bc(do, ht), bc(G[a]["d"], hg)
+                with np.errstate(divide="ignore", invalid="ignore"):
+                    Asch[sc][a, sname] = {"gen_state": gs, "gen_parent": gp, "obsthin_state": os_, "obs_parent": op,
+                                          "obs_state": A[a, sname]["obs_state"],
+                                          "gen_pct": np.where(gp > 0, 100 * gs / gp, np.nan),
+                                          "obsthin_pct": np.where(op > 0, 100 * os_ / op, np.nan)}
+                depth_rows.append({"scheme": sc, "state": sname, "arm": a, "obs_thin": thin_o, "gen_thin": thin_g,
+                                   "depth_matched": bool(sc == "V0_reseed" or a in pool or e[a][k] >= target),
+                                   "obs_lib_median": e["OBS"][0], "gen_lib_median": e[a][0],
+                                   "obs_msum": e["OBS"][1], "gen_msum": e[a][1], "n_ref_genes": nref,
+                                   "msum_over_lib_ratio": (e[a][1] / e["OBS"][1]) / (e[a][0] / e["OBS"][0]),
+                                   "ratio_raw": raw_ratio(Asch[sc][a, sname]),
+                                   "ratio_screen": float(Sx.loc[(a, sname)].gen_over_obs)})
+    DR = pd.DataFrame(depth_rows)
+    write(DR, "depth_arms")
+    dep = []
+    for sc in schemes:
+        comps = MAIN + (REFC if sc in ("V0_reseed", "V1_lib_all", "V2_msum_all") else [])
+        Rd, _, _ = comparison_rows(Asch[sc], states, rare, comps, IDX, sc)
+        dep.append(Rd)
+    DEP = pd.concat([R[R.comparison.isin([c[0] for c in MAIN + REFC])][list(dep[0].columns)]] + dep,
+                    ignore_index=True)
+    write(DEP, "depth")
+    for sc in ["V0_published"] + schemes:
+        t = DEP[(DEP.scheme == sc) & DEP.comparison.isin([c[0] for c in MAIN]) & DEP.state.isin(rare)]
+        a_ = DEP[(DEP.scheme == sc) & (DEP.state == "AGGREGATE")]
+        log(sc, "main state verdicts:", t.verdict.value_counts().to_dict(), "| aggregate:",
+            [(r.comparison[:22], round(r.D, 3), round(r.D_ci_lo, 3), round(r.D_ci_hi, 3)) for r in a_.itertuples()])
+
+    # ===================================================================================== 6. composition
+    strata_def = {}
+    for st in st_json:
+        p = st["parent"]
+        strata_def[st["name"]] = "l2"
+        if p == ["ALL"] or st["kind"] == "label":  # a label state cannot be standardised on its own L2 label
+            strata_def[st["name"]] = "l1"
+    comp_rows, comp_cmp = [], []
+    lab_l2o = lab_o.aifi_l2.to_numpy(str)
+    lab_l1o = lab_o.aifi_l1.to_numpy(str)
+    CS = {}
+    for st in st_json:
+        sname = st["name"]
+        po = parent_mask(lab_o, st["parent"])
+        for level in (["l2", "l1"] if sname == "Cycling T/NK" else [strata_def[sname]]):
+            so = (lab_l2o if level == "l2" else lab_l1o)
+            strata = sorted(set(so[po]))
+            K = len(strata)
+            sidx = {s_: i for i, s_ in enumerate(strata)}
+            for a in ARMS:
+                if st["kind"] == "label":
+                    ht = lab_o.aifi_l2.isin(st["labels"]).to_numpy() & po
+                    pg = parent_mask(G[a]["lab"], st["parent"])
+                    hg = G[a]["lab"].aifi_l2.isin(st["labels"]).to_numpy() & pg
+                else:
+                    ht, hg = calls_v0[a, sname]
+                    pg = parent_mask(G[a]["lab"], st["parent"])
+                sg = G[a]["lab"].aifi_l2.to_numpy(str) if level == "l2" else G[a]["lab"].aifi_l1.to_numpy(str)
+                # per donor x stratum tables
+                ko = np.array([sidx.get(v, -1) for v in so])
+                kg = np.array([sidx.get(v, -1) for v in sg])
+                def tab(codes, kk, mask):
+                    m_ = mask & (kk >= 0)
+                    return np.bincount(codes[m_] * K + kk[m_], minlength=n * K).reshape(n, K).astype(float)
+                OP, OS = tab(do, ko, po), tab(do, ko, ht)
+                GP, GS = tab(G[a]["d"], kg, pg), tab(G[a]["d"], kg, hg)
+                extra_gen = int((pg & (kg < 0)).sum())  # generated parent cells in strata absent from observed
+                CS[a, sname, level] = (OP, OS, GP, GS)
+
+                def std(OP, OS, GP, GS):
+                    op, os_, gp, gs = OP.sum(0), OS.sum(0), GP.sum(0), GS.sum(0)
+                    w = op / op.sum()
+                    keep = gp > 0
+                    with np.errstate(divide="ignore", invalid="ignore"):
+                        rg = np.where(keep, gs / np.where(gp > 0, gp, 1), np.nan)
+                        ro = os_ / np.where(op > 0, op, 1)
+                        Rstd = np.nansum(w[keep] * rg[keep]) / w[keep].sum()
+                        Ro = np.sum(w[keep] * ro[keep]) / w[keep].sum()
+                        raw = (gs.sum() / gp.sum()) / (os_.sum() / op.sum())
+                        wg = gp / gp.sum()
+                        comp_only = np.sum(wg * ro) / (os_.sum() / op.sum())
+                    return Rstd / Ro, raw, comp_only, 1 - w[keep].sum()
+                sr, rr, co_, dropped = std(OP, OS, GP, GS)
+                gpk = GP.sum(0)
+                top = np.argsort(-GS.sum(0))[:3]
+                comp_rows.append({"state": sname, "strata": level, "arm": a, "ratio_raw_v0reseed": rr,
+                                  "ratio_composition_standardised": sr, "composition_only_factor": co_,
+                                  "obs_weight_dropped": dropped, "gen_parent_outside_obs_strata": extra_gen,
+                                  "top_gen_state_strata": "; ".join(f"{strata[i]}:{int(GS.sum(0)[i])}/{int(gpk[i])}"
+                                                                    for i in top if GS.sum(0)[i] > 0),
+                                  "obs_top_state_strata": "; ".join(
+                                      f"{strata[i]}:{int(OS.sum(0)[i])}/{int(OP.sum(0)[i])}"
+                                      for i in np.argsort(-OS.sum(0))[:3] if OS.sum(0)[i] > 0)})
+        # comparisons on the standardised ratio, bootstrap over donors
+        for level in (["l2", "l1"] if sname == "Cycling T/NK" else [strata_def[sname]]):
+            for name, sa, pa in MAIN + REFC:
+                vals = {}
+                for a in (sa, pa):
+                    OP, OS, GP, GS = CS[a, sname, level]
+
+                    def stdb(idx=None):
+                        if idx is None:
+                            op, os_, gp, gs = OP.sum(0), OS.sum(0), GP.sum(0), GS.sum(0)
+                            op, os_, gp, gs = op[None], os_[None], gp[None], gs[None]
+                        else:
+                            op, os_, gp, gs = OP[idx].sum(1), OS[idx].sum(1), GP[idx].sum(1), GS[idx].sum(1)
+                        w = op / op.sum(1, keepdims=True)
+                        keep = gp > 0
+                        with np.errstate(divide="ignore", invalid="ignore"):
+                            rg = np.where(keep, (gs + PC / gs.shape[1]) / np.where(gp > 0, gp, 1), 0.0)
+                            ro = (os_ + PC / os_.shape[1]) / np.where(op > 0, op, 1)
+                            wk = np.where(keep, w, 0.0)
+                            v = np.log2((wk * rg).sum(1) / (wk * ro).sum(1))
+                        return np.where(np.isfinite(v), v, np.nan)
+                    vals[a] = (float(stdb()[0]), stdb(IDX))
+                d0 = abs(vals[sa][0]) - abs(vals[pa][0])
+                db = np.abs(vals[sa][1]) - np.abs(vals[pa][1])
+                lo, hi = pci(db)
+                blo, bhi = bc_ci(db, d0)
+                comp_cmp.append({"state": sname, "strata": level, "comparison": name,
+                                 "std_ratio_scratch": 2 ** vals[sa][0], "std_ratio_pretrained": 2 ** vals[pa][0],
+                                 "D_std": d0, "D_std_ci_lo": lo, "D_std_ci_hi": hi, "verdict_std": verdict(lo, hi),
+                                 "verdict_std_bc": verdict(blo, bhi),
+                                 "D_published": full[(name, sname)].D, "verdict_published": full[(name, sname)].verdict})
+    # aggregate over the 13 rare states on the standardised ratio (default strata; Cycling T/NK on L2)
+    std_l2 = {}
+    for a in ARMS:
+        for s in states:
+            level = strata_def[s]
+            OP, OS, GP, GS = CS[a, s, level]
+
+            def stdv(idx=None):
+                if idx is None:
+                    op, os_, gp, gs = OP.sum(0)[None], OS.sum(0)[None], GP.sum(0)[None], GS.sum(0)[None]
+                else:
+                    op, os_, gp, gs = OP[idx].sum(1), OS[idx].sum(1), GP[idx].sum(1), GS[idx].sum(1)
+                w = op / op.sum(1, keepdims=True)
+                keep = gp > 0
+                with np.errstate(divide="ignore", invalid="ignore"):
+                    rg = np.where(keep, (gs + PC / gs.shape[1]) / np.where(gp > 0, gp, 1), 0.0)
+                    ro = (os_ + PC / os_.shape[1]) / np.where(op > 0, op, 1)
+                    wk = np.where(keep, w, 0.0)
+                    v = np.log2((wk * rg).sum(1) / (wk * ro).sum(1))
+                return np.where(np.isfinite(v), v, np.nan)
+            std_l2[a, s] = (float(stdv()[0]), stdv(IDX))
+    for name, sa, pa in MAIN + REFC:
+        d0 = float(np.mean([abs(std_l2[sa, s][0]) - abs(std_l2[pa, s][0]) for s in rare]))
+        db = np.mean(np.vstack([np.abs(std_l2[sa, s][1]) - np.abs(std_l2[pa, s][1]) for s in rare]), axis=0)
+        lo, hi = pci(db)
+        blo, bhi = bc_ci(db, d0)
+        nv = {"pretrained closer": 0, "scratch closer": 0, "not significant": 0}
+        for s in rare:
+            l_, h_ = pci(np.abs(std_l2[sa, s][1]) - np.abs(std_l2[pa, s][1]))
+            nv[verdict(l_, h_)] = nv.get(verdict(l_, h_), 0) + 1
+        comp_cmp.append({"state": "AGGREGATE (13 rare, standardised)", "strata": "default", "comparison": name,
+                         "std_ratio_scratch": float(np.mean([abs(std_l2[sa, s][0]) for s in rare])),
+                         "std_ratio_pretrained": float(np.mean([abs(std_l2[pa, s][0]) for s in rare])),
+                         "D_std": d0, "D_std_ci_lo": lo, "D_std_ci_hi": hi, "verdict_std": verdict(lo, hi),
+                         "verdict_std_bc": verdict(blo, bhi), "D_published": full[(name, 'AGGREGATE')].D,
+                         "verdict_published": full[(name, 'AGGREGATE')].verdict,
+                         "n_states_pretrained_closer": nv["pretrained closer"],
+                         "n_states_scratch_closer": nv["scratch closer"],
+                         "n_states_not_significant": nv["not significant"]})
+    write(pd.DataFrame(comp_rows), "composition_arms")
+    write(pd.DataFrame(comp_cmp), "composition")
+    log("composition aggregate:\n" + pd.DataFrame(comp_cmp[-len(MAIN + REFC):])[
+        ["comparison", "std_ratio_scratch", "std_ratio_pretrained", "D_std", "D_std_ci_lo", "D_std_ci_hi",
+         "verdict_std", "verdict_std_bc", "n_states_pretrained_closer", "n_states_scratch_closer"]].round(3).to_string())
+
+    # arm-level mean |log2 r_pc| over the 13 rare states under every scheme (is zero-shot still the least faithful?)
+    am = []
+    for sc, AA in [("V0_published", A)] + [(k, Asch[k]) for k in schemes] + [("composition_std", None)]:
+        for a in ARMS:
+            if AA is None:
+                v = [abs(std_l2[a, s][0]) for s in rare]
+            else:
+                v = [abs(float(l2r(AA[a, s]))) for s in rare]
+            am.append({"scheme": sc, "arm": a, "mean_abs_log2_13_rare": float(np.mean(v)),
+                       "depth_matched_in_scheme": bool(sc in ("V0_published", "V0_reseed", "composition_std")
+                                                       or sc.endswith("_all") or a != "zs__raw")})
+    # state-set sensitivity (13 rare vs 11 marker-only vs T/NK states) under every scheme
+    sets = {"13 rare": rare, "11 marker states (no label states)": [s for s in rare if s not in LABEL_STATES],
+            "T/NK states (5)": ["Cycling T/NK", "Cycling activated T (CD38/HLA-DR)", "Proliferating T (label)",
+                                "ISG-high T", "Cytotoxic CD4 T"]}
+    sbs = []
+    for sc in ["V0_published"] + schemes + ["composition_std"]:
+        for name, sa, pa in MAIN + REFC:
+            for lab, ss in sets.items():
+                if sc == "composition_std":
+                    vs = {(a, s): std_l2[a, s] for a in (sa, pa) for s in ss}
+                else:
+                    AA = A if sc == "V0_published" else Asch[sc]
+                    vs = {(a, s): (float(l2r(AA[a, s])), l2r(AA[a, s], idx=IDX)) for a in (sa, pa) for s in ss}
+                d0 = float(np.mean([abs(vs[sa, s][0]) - abs(vs[pa, s][0]) for s in ss]))
+                db = np.mean(np.vstack([np.abs(vs[sa, s][1]) - np.abs(vs[pa, s][1]) for s in ss]), axis=0)
+                lo, hi = pci(db)
+                blo, bhi = bc_ci(db, d0)
+                sbs.append({"scheme": sc, "comparison": name, "state_set": lab, "D": d0, "D_ci_lo": lo,
+                            "D_ci_hi": hi, "verdict": verdict(lo, hi), "D_bc_ci_lo": blo, "D_bc_ci_hi": bhi,
+                            "verdict_bc": verdict(blo, bhi)})
+    SBS = pd.DataFrame(sbs)
+    write(SBS, "stateset_by_scheme")
+    log("state-set x scheme (main comparisons):\n" + SBS[SBS.comparison.isin([c[0] for c in MAIN])].assign(
+        cell=lambda d: d.apply(lambda r: f"{r.D:+.3f}[{r.D_ci_lo:+.2f},{r.D_ci_hi:+.2f}]"
+                                         f"{'*' if r.verdict != 'not significant' else ''}"
+                                         f"{'b' if r.verdict_bc != 'not significant' else ''}", axis=1)).pivot_table(
+        index=["state_set", "comparison"], columns="scheme", values="cell", aggfunc="first").to_string())
+    AM = pd.DataFrame(am)
+    AM["rank_worst_first"] = AM.groupby("scheme").mean_abs_log2_13_rare.rank(ascending=False).astype(int)
+    write(AM, "arm_mean_abslog2")
+    log("arm mean |log2| by scheme:\n" + AM.pivot(index="arm", columns="scheme",
+                                                  values="mean_abs_log2_13_rare").round(3).to_string())
+
+    # ===================================================================================== 7. label vs marker CIs
+    cyc_cols = [sym2col[g] for g in CYC]
+    thin_T = {a: float(Sx.loc[(a, "ISG-high T")].thin) for a in ARMS}
+    rng = np.random.default_rng(SEED)
+    lab_rows, lab_cnt = [], {}
+    To = (lab_o.aifi_l1.to_numpy(str) == "T cell") | (lab_o.aifi_l2.to_numpy(str) == "T cell")
+    PTo = To & (lab_o.aifi_l2.to_numpy(str) == "Proliferating T cell")
+    for a in ARMS:
+        l1 = G[a]["lab"].aifi_l1.to_numpy(str)
+        l2 = G[a]["lab"].aifi_l2.to_numpy(str)
+        T = (l1 == "T cell") | (l2 == "T cell")
+        PT = T & (l2 == "Proliferating T cell")
+        cyc = (G[a]["M"][:, cyc_cols] > 0).sum(1) >= 2
+        d = G[a]["d"]
+        mo = Mo[:, cyc_cols].astype(np.int64)
+        mt = rng.binomial(mo, thin_T[a]) if thin_T[a] < 1 else mo
+        cyco = (mt > 0).sum(1) >= 2
+        lab_cnt[a] = {"gen": {"T": bc(d, T), "PT": bc(d, PT), "PTpass": bc(d, PT & cyc), "cycT": bc(d, cyc & T),
+                              "nonPT": bc(d, T & ~PT), "nonPTpass": bc(d, T & ~PT & cyc)},
+                      "obs": {"T": bc(do, To), "PT": bc(do, PTo), "PTpass": bc(do, PTo & cyco),
+                              "cycT": bc(do, cyco & To), "nonPT": bc(do, To & ~PTo),
+                              "nonPTpass": bc(do, To & ~PTo & cyco)}}
+    def rates(c, idx=None):
+        f = (lambda v: v.sum()) if idx is None else (lambda v: v[idx].sum(-1))
+        with np.errstate(divide="ignore", invalid="ignore"):
+            return {"pass_PT": 100 * f(c["PTpass"]) / f(c["PT"]), "PT_of_T": 100 * f(c["PT"]) / f(c["T"]),
+                    "cyc_of_T": 100 * f(c["cycT"]) / f(c["T"]), "pass_nonPT": 100 * f(c["nonPTpass"]) / f(c["nonPT"]),
+                    "share_cyc_in_PT": 100 * f(c["PTpass"]) / f(c["cycT"])}
+    for a in ARMS:
+        rg, ro = rates(lab_cnt[a]["gen"]), rates(lab_cnt[a]["obs"])
+        rgb, rob = rates(lab_cnt[a]["gen"], IDX), rates(lab_cnt[a]["obs"], IDX)
+        row = {"arm": a, "obs_thin_T": thin_T[a], "gen_PT_cells": lab_cnt[a]["gen"]["PT"].sum(),
+               "gen_PTpass_cells": lab_cnt[a]["gen"]["PTpass"].sum(),
+               "gen_cycling_T_cells": lab_cnt[a]["gen"]["cycT"].sum()}
+        for k in rg:
+            lo, hi = pci(rgb[k])
+            row.update({f"gen_{k}": rg[k], f"gen_{k}_ci_lo": lo, f"gen_{k}_ci_hi": hi, f"obs_{k}": ro[k]})
+        row["gen_over_obs_PT_of_T"] = rg["PT_of_T"] / ro["PT_of_T"]
+        row["gen_over_obs_pass_PT"] = rg["pass_PT"] / ro["pass_PT"]
+        row["gen_over_obs_cyc_of_T"] = rg["cyc_of_T"] / ro["cyc_of_T"]
+        lab_rows.append(row)
+    for name, sa, pa in MAIN:
+        rsb, rpb = rates(lab_cnt[sa]["gen"], IDX), rates(lab_cnt[pa]["gen"], IDX)
+        rs, rp = rates(lab_cnt[sa]["gen"]), rates(lab_cnt[pa]["gen"])
+        row = {"arm": f"DIFF pretrained - scratch | {name}"}
+        for k in ["pass_PT", "PT_of_T", "cyc_of_T", "share_cyc_in_PT"]:
+            lo, hi = pci(rpb[k] - rsb[k])
+            row.update({f"diff_{k}": rp[k] - rs[k], f"diff_{k}_ci_lo": lo, f"diff_{k}_ci_hi": hi})
+        lab_rows.append(row)
+    write(pd.DataFrame(lab_rows), "labelcheck")
+
+    # ===================================================================================== 8. contrasts
+    CONTR = [("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"])]
+
+    def contrast(x, keep_mask):
+        out = {}
+        for cname, ga, gb in CONTR:
+            ma = np.isin(groups, ga) & keep_mask
+            mb = np.isin(groups, gb) & keep_mask
+            if ma.sum() == 0 or mb.sum() == 0:
+                out[cname] = (np.nan, np.nan, np.nan)
+                continue
+            od = np.nanmean(x["obsthin_pct"][ma]) - np.nanmean(x["obsthin_pct"][mb])
+            gd = np.nanmean(x["gen_pct"][ma]) - np.nanmean(x["gen_pct"][mb])
+            lvl = np.nanmean([np.nanmean(x["gen_pct"][ma]), np.nanmean(x["gen_pct"][mb])])
+            out[cname] = (od, gd, lvl)
+        return out
+    allm = np.ones(n, bool)
+    CF = {(a, s): contrast(A[a, s], allm) for a in ARMS for s in states}
+    # eligibility exactly as the claim: rare, min over trained arms |obs_diff| >= 0.5 with one sign
+    elig = []
+    for s in rare:
+        for cname, _, _ in CONTR:
+            od = np.array([CF[a, s][cname][0] for a in TRAINED])
+            if np.all(np.isfinite(od)) and np.abs(od).min() >= 0.5 and len(set(np.sign(od))) == 1:
+                elig.append((s, cname))
+    log("eligible (state, contrast) pairs:", len(elig))
+    crow = []
+    status = {}
+    for a in ARMS:
+        for s, cname in elig:
+            od, gd, lvl = CF[a, s][cname]
+            st_ = "kept" if np.sign(gd) == np.sign(od) else ("flat" if gd == 0 or not np.isfinite(gd) else "reversed")
+            strength = "" if st_ != "reversed" else ("strong" if abs(gd) >= 0.5 else "weak")
+            rel = abs(gd) / lvl if lvl and np.isfinite(lvl) and lvl > 0 else np.nan
+            strength_rel = "" if st_ != "reversed" else ("strong" if rel >= 0.5 else "weak")
+            status[a, s, cname] = st_
+            crow.append({"arm": a, "state": s, "contrast": cname, "obs_diff": od, "gen_diff": gd,
+                         "gen_level_mean_pct": lvl, "rel_gen_diff": rel, "status": st_,
+                         "reversal_strength_abs_0.5pp": strength, "reversal_strength_rel_0.5": strength_rel})
+    CR = pd.DataFrame(crow)
+    # LODO
+    lodo_c = []
+    for j in range(n):
+        km = allm.copy()
+        km[j] = False
+        for a in ARMS:
+            kept = undefined = obs_flip = 0
+            for s, cname in elig:
+                od, gd, _ = contrast(A[a, s], km)[cname]
+                od_full = CF[a, s][cname][0]
+                if not np.isfinite(od) or not np.isfinite(gd):
+                    undefined += 1
+                    continue
+                obs_flip += int(np.sign(od) != np.sign(od_full))
+                kept += int(np.sign(gd) == np.sign(od))
+            lodo_c.append({"left_out": donors[j], "group": groups[j], "arm": a, "kept": kept,
+                           "undefined": undefined, "obs_direction_flips": obs_flip})
+    LC = pd.DataFrame(lodo_c)
+    summ = []
+    for a in ARMS:
+        t = CR[CR.arm == a]
+        lc = LC[LC.arm == a]
+        summ.append({"arm": a, "n_eligible": len(t), "kept": int((t.status == "kept").sum()),
+                     "reversed_strong_abs": int((t["reversal_strength_abs_0.5pp"] == "strong").sum()),
+                     "reversed_weak_abs": int((t["reversal_strength_abs_0.5pp"] == "weak").sum()),
+                     "flat": int((t.status == "flat").sum()),
+                     "reversed_strong_rel": int((t["reversal_strength_rel_0.5"] == "strong").sum()),
+                     "reversed_weak_rel": int((t["reversal_strength_rel_0.5"] == "weak").sum()),
+                     "kept_lodo_min": int(lc.kept.min()), "kept_lodo_max": int(lc.kept.max()),
+                     "kept_by_contrast": "; ".join(f"{c}:{int(((t.contrast == c) & (t.status == 'kept')).sum())}/"
+                                                   f"{int((t.contrast == c).sum())}" for c, _, _ in CONTR)})
+    for name, sa, pa in MAIN + REFC:
+        b = sum(status[pa, s, c] == "kept" and status[sa, s, c] != "kept" for s, c in elig)
+        c_ = sum(status[sa, s, c] == "kept" and status[pa, s, c] != "kept" for s, c in elig)
+        p = binomtest(b, b + c_, 0.5).pvalue if b + c_ > 0 else np.nan
+        dl = (LC[LC.arm == pa].set_index("left_out").kept - LC[LC.arm == sa].set_index("left_out").kept)
+        summ.append({"arm": f"PAIR {name}", "n_eligible": len(elig),
+                     "kept_diff_pretrained_minus_scratch": sum(status[pa, s, c] == "kept" for s, c in elig)
+                     - sum(status[sa, s, c] == "kept" for s, c in elig),
+                     "discordant_pretrained_only_kept": b, "discordant_scratch_only_kept": c_,
+                     "exact_sign_test_p": p, "kept_diff_lodo_min": int(dl.min()), "kept_diff_lodo_max": int(dl.max())})
+    obs_fragile = LC[LC.arm == TRAINED[0]][["left_out", "group", "obs_direction_flips", "undefined"]]
+    write(pd.concat([CR.assign(section="pair"), pd.DataFrame(summ).assign(section="summary"),
+                     LC.assign(section="lodo")], ignore_index=True), "contrasts")
+    log("contrast summary:\n" + pd.DataFrame(summ).to_string(index=False))
+    log("observed-direction flips per left-out donor (arm lora_n5):\n" + obs_fragile.to_string(index=False))
+
+    # ===================================================================================== 9. Spearman
+    sp_rows = []
+    R0, RB = {}, {}
+    for a in ARMS:
+        for s in states:
+            g, o = A[a, s]["gen_pct"], A[a, s]["obsthin_pct"]
+            R0[a, s] = spearman(g, o)
+            RB[a, s] = spearman_rows(g[IDX], o[IDX])
+    rng = np.random.default_rng(SEED)
+    ceil = {}
+    for a in ARMS:
+        for s in states:
+            x = A[a, s]
+            c = raw_ratio(x)
+            p = np.clip(np.nan_to_num(x["obsthin_pct"]) / 100 * (c if np.isfinite(c) else 1.0), 0, 1)
+            sims = []
+            for _ in range(500):
+                gs = rng.binomial(x["gen_parent"].astype(np.int64), p)
+                with np.errstate(divide="ignore", invalid="ignore"):
+                    gp = np.where(x["gen_parent"] > 0, 100 * gs / x["gen_parent"], np.nan)
+                sims.append(spearman(gp, x["obsthin_pct"]))
+            sims = np.array(sims, float)
+            ceil[a, s] = (np.nanmean(sims), *pci(sims), np.nanstd(sims))
+            sep = sepsis & np.isfinite(x["gen_pct"]) & np.isfinite(x["obsthin_pct"])
+            sp_rows.append({"arm": a, "state": s, "spearman": R0[a, s], "ceiling_mean": ceil[a, s][0],
+                            "ceiling_ci_lo": ceil[a, s][1], "ceiling_ci_hi": ceil[a, s][2],
+                            "ceiling_sd": ceil[a, s][3],
+                            "spearman_over_ceiling": R0[a, s] / ceil[a, s][0] if ceil[a, s][0] else np.nan,
+                            "spearman_within_sepsis_only": spearman(x["gen_pct"][sep], x["obsthin_pct"][sep]),
+                            "median_gen_state_cells_per_donor": float(np.median(x["gen_state"]))})
+    for name, sa, pa in MAIN:
+        d0 = float(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 = pci(db)
+        lo90, hi90 = np.percentile(db[np.isfinite(db)], [5, 95])
+        cs, cp = np.mean([ceil[sa, s][0] for s in rare]), np.mean([ceil[pa, s][0] for s in rare])
+        sep_s = np.nanmean([r["spearman_within_sepsis_only"] for r in sp_rows if r["arm"] == sa and r["state"] in rare])
+        sep_p = np.nanmean([r["spearman_within_sepsis_only"] for r in sp_rows if r["arm"] == pa and r["state"] in rare])
+        nsig = 0
+        npos = 0
+        for s in rare:
+            l_, h_ = pci(RB[pa, s] - RB[sa, s])
+            nsig += int(l_ > 0 or h_ < 0)
+            npos += int(R0[pa, s] - R0[sa, s] > 0)
+        sp_rows.append({"arm": f"DIFF pretrained - scratch | {name}", "state": "MEAN over 13 rare",
+                        "spearman": d0, "ceiling_mean": cp - cs, "diff_ci_lo": lo, "diff_ci_hi": hi,
+                        "diff_ci90_lo": lo90, "diff_ci90_hi": hi90, "mean_spearman_scratch": np.mean([R0[sa, s] for s in rare]),
+                        "mean_spearman_pretrained": np.mean([R0[pa, s] for s in rare]),
+                        "mean_ceiling_scratch": cs, "mean_ceiling_pretrained": cp,
+                        "mean_within_sepsis_scratch": sep_s, "mean_within_sepsis_pretrained": sep_p,
+                        "n_states_sig": nsig, "n_states_pretrained_higher": npos})
+    write(pd.DataFrame(sp_rows), "spearman")
+
+    # ===================================================================================== 10. folds / LoRA series
+    PP = pd.read_csv(SRC / "sepsis_per_donor.csv")
+    folds = pd.read_csv(FOLDS).set_index("sample_id").fold
+    PP["fold"] = PP.donor.map(folds)
+    fr = []
+    for (a, f), t in PP.groupby(["arm", "fold"]):
+        if f < 0:
+            continue
+        absl_ = []
+        for s in states:
+            u = t[t.state == s]
+            x = {k: u[k].to_numpy(float) for k in ["gen_state", "gen_parent", "obsthin_state", "obs_parent"]}
+            v = float(l2r(x))
+            if s in rare:
+                absl_.append(abs(v))
+            fr.append({"source": "pooled cross-fitted CSV", "arm": a, "fold": int(f), "state": s,
+                       "n_donors": len(u), "ratio_raw": raw_ratio(x), "log2_pc": v})
+        fr.append({"source": "pooled cross-fitted CSV", "arm": a, "fold": int(f),
+                   "state": "MEAN |log2| over 13 rare", "log2_pc": float(np.mean(absl_))})
+    for (s, f), t in PP[PP.arm == "real_lora__raw"].groupby(["state", "fold"]):
+        if f < 0:
+            continue
+        fr.append({"source": "pooled cross-fitted CSV, observed side", "arm": "observed (thinned to real_lora)",
+                   "fold": int(f), "state": s, "n_donors": len(t), "obsthin_state": int(t.obsthin_state.sum()),
+                   "obs_parent": int(t.obs_parent.sum()),
+                   "obs_top_donor_share": float(t.obsthin_state.max() / t.obsthin_state.sum())
+                   if t.obsthin_state.sum() else np.nan})
+    for a in ARMS:
+        fr.append({"source": "fold0 CSV", "arm": a, "fold": 0, "state": "MEAN |log2| over 13 rare",
+                   "log2_pc": float(np.mean([abs(L0.get((a, s), float(l2r(A[a, s])))) for s in rare]))})
+        for s in states:
+            fr.append({"source": "fold0 CSV", "arm": a, "fold": 0, "state": s, "n_donors": n,
+                       "ratio_raw": raw_ratio(A[a, s]), "log2_pc": float(l2r(A[a, s]))})
+    FR = pd.DataFrame(fr)
+    # substitution: scratch arm vs LoRA arms of other pair counts on fold-0 donors (each with its own reference)
+    sub_rows = []
+    d0f = PP[PP.fold == 0]
+    for la in ["lora_n5__raw", "lora_n10__raw", "lora_n20__raw", "lora_n40__raw", "real_lora__raw"]:
+        Lx = {}
+        for s in states:
+            u = d0f[(d0f.arm == la) & (d0f.state == s)].set_index("donor").loc[donors]
+            Lx[s] = {k: u[k].to_numpy(float) for k in ["gen_state", "gen_parent", "obsthin_state", "obs_parent"]}
+        for sa in ["scratch_n5__raw", "scratch_full__raw", "scratch_recipe__raw"]:
+            ds, dbs = [], []
+            for s in states:
+                ls_, lp_ = float(l2r(A[sa, s])), float(l2r(Lx[s]))
+                d = abs(ls_) - abs(lp_)
+                db = np.abs(l2r(A[sa, s], idx=IDX)) - np.abs(l2r(Lx[s], idx=IDX))
+                lo, hi = pci(db)
+                sub_rows.append({"scratch_arm": sa, "lora_arm_pooled_csv": la, "state": s,
+                                 "ratio_scratch": raw_ratio(A[sa, s]), "ratio_lora": raw_ratio(Lx[s]),
+                                 "D": d, "D_ci_lo": lo, "D_ci_hi": hi, "verdict": verdict(lo, hi)})
+                if s in rare:
+                    ds.append(d)
+                    dbs.append(db)
+            db = np.mean(np.vstack(dbs), axis=0)
+            lo, hi = pci(db)
+            sub_rows.append({"scratch_arm": sa, "lora_arm_pooled_csv": la, "state": "AGGREGATE",
+                             "D": float(np.mean(ds)), "D_ci_lo": lo, "D_ci_hi": hi, "verdict": verdict(lo, hi)})
+    write(pd.concat([FR.assign(section="per fold"), pd.DataFrame(sub_rows).assign(section="lora substitution")],
+                    ignore_index=True), "folds")
+    log("done")
+
+
+if __name__ == "__main__":
+    main()