From 10a6a23984f5d50dca75e02054ec25a9cfabd2d5 Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Fri, 24 Jul 2026 14:29:06 +0200
Subject: [PATCH 1/7] feat: MIMIC-CXR deterministic subset selector + download
 list (#92, #295)

Select a nested, seed-deterministic MIMIC-CXR study subset and emit the
download list for just those images, so the imaging battery runs without
pulling the ~600 GB release.

- build_subset.py: `select` ranks studies via budget.subsample_cases (nested
  arms: 100 < 150 < 300 < 600, with 35 nested for the NIH-matched comparison)
  and writes per-arm manifests + download_list.txt; `verify` checks images
  resolve and writes sha256 provenance, mirroring the NIH imaging lane.
- All images per study; finding-positive studies by default.
- Reproducibility = deterministic list (from seed) + pinned per-arm manifests
  + provenance checksums + a standard-tool wget one-liner (no bespoke fetcher,
  no credentials in the repo), matching how the NIH manifest pins its data.
- Manifest CSVs are gitignored: they embed credentialed report text and
  regenerate from the seed (README documents the workflow).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 experiments/mimic_cxr_image/.gitignore        |   5 +
 experiments/mimic_cxr_image/README.md         | 110 ++++++++++
 experiments/mimic_cxr_image/build_subset.py   | 199 ++++++++++++++++++
 .../manifests/selection_summary.json          |  39 ++++
 tests/test_mimic_subset.py                    |  87 ++++++++
 5 files changed, 440 insertions(+)
 create mode 100644 experiments/mimic_cxr_image/.gitignore
 create mode 100644 experiments/mimic_cxr_image/README.md
 create mode 100644 experiments/mimic_cxr_image/build_subset.py
 create mode 100644 experiments/mimic_cxr_image/manifests/selection_summary.json
 create mode 100644 tests/test_mimic_subset.py

diff --git a/experiments/mimic_cxr_image/.gitignore b/experiments/mimic_cxr_image/.gitignore
new file mode 100644
index 0000000..734d4e9
--- /dev/null
+++ b/experiments/mimic_cxr_image/.gitignore
@@ -0,0 +1,5 @@
+# Generated by build_subset.py and reproducible from the seed (see README).
+# The per-arm CSVs embed credentialed MIMIC-CXR report text, so they must not be committed.
+manifests/*.csv
+manifests/download_list.txt
+manifests/provenance.json
diff --git a/experiments/mimic_cxr_image/README.md b/experiments/mimic_cxr_image/README.md
new file mode 100644
index 0000000..75f590e
--- /dev/null
+++ b/experiments/mimic_cxr_image/README.md
@@ -0,0 +1,110 @@
+# MIMIC-CXR imaging subset (Lane A): download + battery (#92, #295)
+
+Replicates the NIH ChestX-ray14 imaging standard battery on MIMIC-CXR so imaging results are
+apples-to-apples across datasets. The full release is ~600 GB; we never download it. We build the
+manifest from the small metadata CSVs, select a deterministic nested study subset, and download
+only the images those studies reference (~800 images for the 600-study superset).
+
+## 0. Data prerequisites (credentialed, one time)
+
+You need PhysioNet credentialed access to MIMIC-CXR-JPG v2.1.0 (images/labels; v2.0.0 is not
+accessible) and MIMIC-CXR v2.0.0 (reports).
+Download only the small metadata and reports first (tens of MB, no images):
+
+```bash
+mkdir -p ~/mimic-cxr-raw && cd ~/mimic-cxr-raw
+
+wget -N -c --user YOUR_PHYSIONET_USER --ask-password \
+  https://physionet.org/files/mimic-cxr-jpg/2.1.0/mimic-cxr-2.0.0-metadata.csv.gz \
+  https://physionet.org/files/mimic-cxr-jpg/2.1.0/mimic-cxr-2.0.0-chexpert.csv.gz
+wget -N -c --user YOUR_PHYSIONET_USER --ask-password \
+  https://physionet.org/files/mimic-cxr/2.0.0/mimic-cxr-reports.zip
+
+gunzip -f mimic-cxr-2.0.0-*.csv.gz
+unzip -q mimic-cxr-reports.zip     # unpacks files/pXX/pYYYY/sZZZZ.txt (the adapter's report path)
+```
+
+The adapter (`benchmaxxing/datasets/mimic_cxr.py`) builds the manifest from these CSVs alone; no
+image needs to be on disk to select the subset.
+
+## 1. Select the nested study subset (`build_subset.py select`)
+
+Ranks studies by a stable hash of the seed and takes the top N per arm. The arm sizes nest, so
+every arm is a strict subset of the 600-study superset, and a 35-study set nests inside the 600
+for the matched NIH comparison. One seed fixes the whole set; the same seed reproduces the identical
+`download_list.txt` byte for byte.
+
+```bash
+python -m experiments.mimic_cxr_image.build_subset select \
+  --raw-root ~/mimic-cxr-raw \
+  --out-dir experiments/mimic_cxr_image/manifests \
+  --seed 20240724
+```
+
+Writes per-arm manifests (`solo_600.csv`, `cross_modal_600.csv`, `referee_300.csv`,
+`cascade_150.csv`, `blind_metric_100.csv`, `nih_match_35.csv`), a `download_list.txt` of the image
+URLs for the 600-study superset (the union of every arm), and `selection_summary.json`.
+
+Defaults (from the tracker): solo/cross-modal 600 studies, referee 300, cascade 150, blind-metric
+100, NIH-match 35. Only finding-positive (pneumothorax) studies are selected, matching the imaging
+pipeline; pass `--include-no-finding` to keep negatives too. A study contributes all of its images
+(frontal + lateral), so image counts run a little above the study counts.
+
+Building the full manifest reads ~227k report files (~30 s). To iterate faster, build it once and
+reuse it with `--full-manifest path/to/full_manifest.csv`.
+
+## 2. Download only the selected images
+
+The list is plain URLs, so the fetch is a standard-tool one-liner with your own credentials (no
+secrets in the repo). This is the reproducible download: same seed gives the same list.
+
+```bash
+cd ~/mimic-cxr-raw
+wget -N -c --user YOUR_PHYSIONET_USER --ask-password \
+  -i /path/to/experiments/mimic_cxr_image/manifests/download_list.txt \
+  -x -nH --cut-dirs=3
+# -x -nH --cut-dirs=3 recreates files/pXX/... under the current dir, matching image_ref.
+```
+
+(The requester-pays AWS mirror `s3://mimic-cxr-jpg-2.1.0.physionet.org/` works too; read the same
+list with `aws s3 cp`.)
+
+## 3. Verify + provenance (`build_subset.py verify`)
+
+After the download, confirm every referenced image resolves and pin a sha256 per image (same
+auditable-pixels guarantee as the NIH manifest):
+
+```bash
+python -m experiments.mimic_cxr_image.build_subset verify \
+  --manifest experiments/mimic_cxr_image/manifests/solo_600.csv \
+  --image-root ~/mimic-cxr-raw \
+  --provenance experiments/mimic_cxr_image/manifests/provenance.json
+```
+
+## 4. Run the battery
+
+Point the existing imaging runners at the per-arm manifests (they are dataset-agnostic):
+
+```bash
+export GEMINI_API_KEY=...   # multimodal Gemini; compute is API-side, no local GPU
+
+# #310 solo susceptibility + noise floor
+python -m experiments.imaging.imaging_solo \
+  --manifest experiments/mimic_cxr_image/manifests/solo_600.csv \
+  --image-root ~/mimic-cxr-raw \
+  --out experiments/mimic_cxr_image/results --n 600
+
+# #311 cascade -> cascade_150.csv ; #315 referee -> referee_300.csv ;
+# #314 blind-metric -> blind_metric_100.csv ; #312 system-flag, #313 cue-strength -> solo_600.csv
+```
+
+Results land under `experiments/mimic_cxr_image/results/`, same format as
+`experiments/imaging/results/`, and feed issue #295's cross-dataset table.
+
+## Reproducibility
+
+Three artifacts pin a run, mirroring the NIH lane:
+
+- `download_list.txt` + the seed: which images (deterministic from the seed).
+- the per-arm manifests: which cases each arm ran on (pinned case_ids).
+- `provenance.json`: the exact pixels (sha256 per image).
diff --git a/experiments/mimic_cxr_image/build_subset.py b/experiments/mimic_cxr_image/build_subset.py
new file mode 100644
index 0000000..aa23e06
--- /dev/null
+++ b/experiments/mimic_cxr_image/build_subset.py
@@ -0,0 +1,199 @@
+"""Select a deterministic, nested MIMIC-CXR study subset and emit its download list (#92, #295).
+
+The full MIMIC-CXR-JPG release is ~600 GB, but the imaging battery only needs a few hundred
+studies per arm, and the arm sizes nest (blind 100 < cascade 150 < referee 300 < solo/cross-modal
+600, with a 35-study set nested inside the 600 for an apples-to-apples comparison against the NIH
+ChestX-ray14 run). So we never download the whole release: we build the manifest from the small
+metadata CSVs (no images required on disk), rank *studies* by a stable hash of the seed, take the
+top N for each arm, and write one ``download_list.txt`` of just the images in the 600-study
+superset. The union of every arm is exactly that superset, so a single download covers all arms.
+
+Determinism and nesting both come from ``benchmaxxing.budget.subsample_cases`` (hash-ranked, so
+the selection depends only on study identity, not on the order the pool arrives in). Same seed
+gives the identical list byte for byte, which is what makes the download reproducible: the list
+plus the per-arm manifests plus the ``verify`` provenance checksums are the reproducibility
+artifacts, exactly as the NIH imaging manifest pins its cases and sha256s its pixels.
+
+Two modes:
+
+    select   build/reuse the full manifest, rank studies, write per-arm manifests + download_list.txt
+    verify   after the image download: confirm every referenced image resolves and write provenance.json
+
+Selection needs only the metadata CSVs + reports (what ``mimic_cxr.build_manifest`` reads); it does
+not need any image on disk. ``verify`` is the step that needs the downloaded images.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import tempfile
+from pathlib import Path
+
+from benchmaxxing.budget import RunBudget, subsample_cases
+from benchmaxxing.data import load_cases
+from benchmaxxing.datasets import mimic_cxr
+from benchmaxxing.datasets.base import finalize
+
+# Arm -> number of studies. solo and cross-modal share the 600 superset; every smaller arm is a
+# strict subset of it, so the download only ever needs the 600. nih_match is the 35 nested inside
+# the 600 for the matched NIH comparison.
+DEFAULT_SIZES = {
+    "solo": 600,
+    "cross_modal": 600,
+    "referee": 300,
+    "cascade": 150,
+    "blind_metric": 100,
+    "nih_match": 35,
+}
+
+DEFAULT_URL_BASE = "https://physionet.org/files/mimic-cxr-jpg/2.1.0/"
+
+
+def _study_key(case) -> str:
+    """Stable per-study identity: ``patient_id/study_id``. study_id alone is globally unique in
+    MIMIC, but pairing it with the subject id is defensive and self-documenting."""
+    return f"{case.patient_id}/{case.meta.get('study_id')}"
+
+
+def _is_finding(case) -> bool:
+    """True when the case carries a real finding label (the adapter emits 'pneumothorax' vs
+    'no finding'). Mirrors the eligibility filter the NIH imaging pipeline uses."""
+    return bool(case.label) and case.label.strip().lower() not in ("no finding", "", "none")
+
+
+def select_arms(cases, seed: int, sizes: dict[str, int], require_finding: bool = True) -> dict[str, list]:
+    """Group cases into studies, rank studies deterministically by ``seed``, and return the nested
+    per-arm case lists.
+
+    Each arm gets *all* images of its top-N studies. Because every arm ranks the same study pool
+    with the same seed, the smaller arms are strict subsets of the larger ones: the top-100 studies
+    are a prefix of the top-300, which are a prefix of the top-600 (the prefix property of
+    :func:`subsample_cases`). Returns ``{arm_name: [Case, ...]}``.
+    """
+    eligible = [c for c in cases if not require_finding or _is_finding(c)]
+    studies: dict[str, list] = {}
+    for case in eligible:
+        studies.setdefault(_study_key(case), []).append(case)
+    study_keys = list(studies)
+
+    arms: dict[str, list] = {}
+    for arm, n in sizes.items():
+        picked = subsample_cases(study_keys, RunBudget(max_cases=n, seed=seed))
+        arms[arm] = [case for key in picked for case in studies[key]]
+    return arms
+
+
+def _download_lines(cases, url_base: str) -> list[str]:
+    """One URL per unique image in ``cases``, in a deterministic order, for ``wget -i``."""
+    base = url_base.rstrip("/") + "/"
+    seen: dict[str, None] = {}
+    for case in cases:
+        if case.image_ref and case.image_ref not in seen:
+            seen[case.image_ref] = None
+    return [base + ref for ref in seen]
+
+
+def _build_full_cases(raw_root: str, full_manifest: str | None):
+    """Return every case in the release. Reuses ``--full-manifest`` when given (fast reruns),
+    otherwise builds it once into a temp file (discarded) via the registered adapter."""
+    if full_manifest and Path(full_manifest).is_file():
+        return load_cases(full_manifest)
+    with tempfile.TemporaryDirectory() as tmp:
+        return mimic_cxr.build_manifest(raw_root, Path(tmp) / "full_manifest.csv")
+
+
+def _sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def do_select(args) -> None:
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    sizes = dict(DEFAULT_SIZES)
+
+    all_cases = _build_full_cases(args.raw_root, args.full_manifest)
+    arms = select_arms(all_cases, seed=args.seed, sizes=sizes, require_finding=not args.include_no_finding)
+
+    written = {}
+    for arm, cases in arms.items():
+        path = out_dir / f"{arm}_{sizes[arm]}.csv"
+        finalize(cases, path)
+        n_studies = len({_study_key(c) for c in cases})
+        written[arm] = {"manifest": str(path), "studies": n_studies, "images": len(cases)}
+
+    # The download superset is the largest arm; every other arm is nested inside it.
+    superset = max(arms.values(), key=len)
+    lines = _download_lines(superset, args.url_base)
+    (out_dir / "download_list.txt").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    summary = {
+        "seed": args.seed,
+        "require_finding": not args.include_no_finding,
+        "url_base": args.url_base,
+        "arms": written,
+        "download_list": str(out_dir / "download_list.txt"),
+        "download_images": len(lines),
+    }
+    (out_dir / "selection_summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
+    print(json.dumps(summary, indent=2))
+
+
+def do_verify(args) -> None:
+    image_root = Path(args.image_root)
+    cases = load_cases(args.manifest)
+    missing = [c.image_ref for c in cases if not (image_root / c.image_ref).is_file()]
+    if missing:
+        raise SystemExit(
+            f"{len(missing)}/{len(cases)} images not found under {image_root} "
+            f"(first few: {missing[:5]}). Run the download first."
+        )
+    provenance = {
+        "manifest": str(args.manifest),
+        "image_root": str(image_root),
+        "n_cases": len(cases),
+        "cases": [
+            {
+                "case_id": c.case_id,
+                "image_ref": c.image_ref,
+                "label": c.label,
+                "sha256": _sha256(image_root / c.image_ref),
+                "bytes": (image_root / c.image_ref).stat().st_size,
+            }
+            for c in cases
+        ],
+    }
+    Path(args.provenance).write_text(json.dumps(provenance, indent=2), encoding="utf-8")
+    print(json.dumps({"n_cases": len(cases), "provenance": str(args.provenance), "all_present": True}, indent=2))
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = ap.add_subparsers(dest="mode", required=True)
+
+    sel = sub.add_parser("select", help="rank studies and write per-arm manifests + download_list.txt")
+    sel.add_argument("--raw-root", required=True, help="dir with the metadata/chexpert CSVs and unpacked reports")
+    sel.add_argument("--out-dir", required=True, help="output dir for per-arm manifests + download list")
+    sel.add_argument("--seed", type=int, default=0, help="selection seed (fixes the nested study set)")
+    sel.add_argument("--url-base", default=DEFAULT_URL_BASE, help="prefix for image_ref paths in download_list.txt")
+    sel.add_argument("--full-manifest", default=None, help="reuse a prebuilt full manifest instead of rebuilding")
+    sel.add_argument("--include-no-finding", action="store_true", help="keep 'no finding' studies too (default: findings only)")
+    sel.set_defaults(func=do_select)
+
+    ver = sub.add_parser("verify", help="check images resolve on disk and write provenance.json")
+    ver.add_argument("--manifest", required=True, help="a per-arm manifest (usually the 600-study superset)")
+    ver.add_argument("--image-root", required=True, help="dir holding the downloaded images")
+    ver.add_argument("--provenance", required=True, help="output provenance JSON path (sha256 per image)")
+    ver.set_defaults(func=do_verify)
+
+    args = ap.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/experiments/mimic_cxr_image/manifests/selection_summary.json b/experiments/mimic_cxr_image/manifests/selection_summary.json
new file mode 100644
index 0000000..9d1d389
--- /dev/null
+++ b/experiments/mimic_cxr_image/manifests/selection_summary.json
@@ -0,0 +1,39 @@
+{
+  "seed": 20240724,
+  "require_finding": true,
+  "url_base": "https://physionet.org/files/mimic-cxr-jpg/2.1.0/",
+  "arms": {
+    "solo": {
+      "manifest": "experiments/mimic_cxr_image/manifests/solo_600.csv",
+      "studies": 600,
+      "images": 834
+    },
+    "cross_modal": {
+      "manifest": "experiments/mimic_cxr_image/manifests/cross_modal_600.csv",
+      "studies": 600,
+      "images": 834
+    },
+    "referee": {
+      "manifest": "experiments/mimic_cxr_image/manifests/referee_300.csv",
+      "studies": 300,
+      "images": 417
+    },
+    "cascade": {
+      "manifest": "experiments/mimic_cxr_image/manifests/cascade_150.csv",
+      "studies": 150,
+      "images": 215
+    },
+    "blind_metric": {
+      "manifest": "experiments/mimic_cxr_image/manifests/blind_metric_100.csv",
+      "studies": 100,
+      "images": 141
+    },
+    "nih_match": {
+      "manifest": "experiments/mimic_cxr_image/manifests/nih_match_35.csv",
+      "studies": 35,
+      "images": 50
+    }
+  },
+  "download_list": "experiments/mimic_cxr_image/manifests/download_list.txt",
+  "download_images": 834
+}
\ No newline at end of file
diff --git a/tests/test_mimic_subset.py b/tests/test_mimic_subset.py
new file mode 100644
index 0000000..a7f1fd8
--- /dev/null
+++ b/tests/test_mimic_subset.py
@@ -0,0 +1,87 @@
+"""Tests for the MIMIC-CXR subset selector: study-level nesting, expansion, and determinism.
+
+Pure shape tests on synthetic Cases: no raw tree, no images, no network.
+"""
+
+from __future__ import annotations
+
+import random
+
+from benchmaxxing.schema import Case, Modality
+from experiments.mimic_cxr_image.build_subset import _download_lines, _study_key, select_arms
+
+
+def _case(study: int, dicom: int, label: str = "pneumothorax"):
+    """One image in study ``study``. Two dicoms per study model MIMIC's frontal+lateral pair."""
+    subject = 10_000 + study
+    return Case(
+        case_id=f"d{study}_{dicom}",
+        patient_id=str(subject),
+        modality=Modality.IMAGE,
+        label=label,
+        image_ref=f"files/p{str(subject)[:2]}/p{subject}/s{study}/d{study}_{dicom}.jpg",
+        meta={"study_id": str(study)},
+    )
+
+
+def _pool(n_studies: int, images_per_study: int = 2, label: str = "pneumothorax"):
+    return [_case(s, d, label) for s in range(n_studies) for d in range(images_per_study)]
+
+
+def _study_set(cases):
+    return {_study_key(c) for c in cases}
+
+
+def test_smaller_arms_are_strict_subsets_of_larger_ones():
+    # The whole point of one seed: blind < cascade < referee < solo must nest at study level.
+    cases = _pool(50)
+    sizes = {"solo": 30, "referee": 20, "cascade": 10, "nih_match": 5}
+    arms = select_arms(cases, seed=7, sizes=sizes)
+    solo, referee, cascade, nih = map(_study_set, (arms["solo"], arms["referee"], arms["cascade"], arms["nih_match"]))
+    assert nih < cascade < referee < solo
+    assert len(solo) == 30 and len(nih) == 5
+
+
+def test_all_images_of_a_selected_study_are_kept():
+    # "All images per study": a picked study contributes every one of its images, not just one.
+    cases = _pool(20, images_per_study=3)
+    arms = select_arms(cases, seed=1, sizes={"solo": 5})
+    picked = arms["solo"]
+    assert len(_study_set(picked)) == 5
+    assert len(picked) == 15  # 5 studies x 3 images
+    for key in _study_set(picked):
+        assert sum(1 for c in picked if _study_key(c) == key) == 3
+
+
+def test_selection_is_invariant_to_pool_order():
+    # Study ranking depends on content, not arrival order: a reshuffled pool selects the same studies.
+    cases = _pool(40)
+    shuffled = cases[:]
+    random.Random(123).shuffle(shuffled)
+    a = select_arms(cases, seed=3, sizes={"solo": 12})["solo"]
+    b = select_arms(shuffled, seed=3, sizes={"solo": 12})["solo"]
+    assert _study_set(a) == _study_set(b)
+
+
+def test_no_finding_studies_are_dropped_by_default():
+    findings = _pool(10, label="pneumothorax")
+    negatives = [_case(s, d, label="no finding") for s in range(100, 110) for d in range(2)]
+    arms = select_arms(findings + negatives, seed=0, sizes={"solo": 10})
+    # Only the 10 finding studies are eligible, so the arm is exactly those.
+    assert len(_study_set(arms["solo"])) == 10
+    assert all(c.label == "pneumothorax" for c in arms["solo"])
+
+
+def test_include_no_finding_keeps_negatives():
+    findings = _pool(5, label="pneumothorax")
+    negatives = [_case(s, d, label="no finding") for s in range(100, 105) for d in range(2)]
+    arms = select_arms(findings + negatives, seed=0, sizes={"solo": 10}, require_finding=False)
+    assert len(_study_set(arms["solo"])) == 10
+
+
+def test_download_lines_are_unique_and_prefixed():
+    cases = _pool(3, images_per_study=2)
+    lines = _download_lines(cases, "https://physionet.org/files/mimic-cxr-jpg/2.1.0/")
+    assert len(lines) == 6  # 3 studies x 2 images, all distinct
+    assert len(set(lines)) == 6
+    assert all(u.startswith("https://physionet.org/files/mimic-cxr-jpg/2.1.0/files/") for u in lines)

From ee789f0c36af7052a469b4dce16690392ce0250c Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Fri, 24 Jul 2026 20:17:10 +0200
Subject: [PATCH 2/7] docs: complete MIMIC-CXR README repro (deps step, all six
 arms, --n fix)

- add the imaging+model dependency install step (runners need the image extra
  plus google-genai; a fresh follow hit ModuleNotFoundError without it)
- give the full per-arm battery commands incl. the referee/cascade dependency
- --n 9999 (all images in the arm); the prior --n 600 silently dropped 234 of
  the 834 solo images

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 experiments/mimic_cxr_image/README.md | 29 +++++++++++++++++++--------
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/experiments/mimic_cxr_image/README.md b/experiments/mimic_cxr_image/README.md
index 75f590e..1eb9125 100644
--- a/experiments/mimic_cxr_image/README.md
+++ b/experiments/mimic_cxr_image/README.md
@@ -83,19 +83,32 @@ python -m experiments.mimic_cxr_image.build_subset verify \
 
 ## 4. Run the battery
 
-Point the existing imaging runners at the per-arm manifests (they are dataset-agnostic):
+One-time, install the imaging + model deps (full setup in `CONTRIBUTING.md`). The imaging runners
+need the `image` extra (Pillow/OpenCV cue injection) and the Gemini client; `.[models]` (torch +
+transformers) is only needed for the open-weights cross-lineage arm.
 
 ```bash
+pip install -e ".[image,changepoint,stats]" && pip install "google-genai>=0.3"
 export GEMINI_API_KEY=...   # multimodal Gemini; compute is API-side, no local GPU
+```
 
-# #310 solo susceptibility + noise floor
-python -m experiments.imaging.imaging_solo \
-  --manifest experiments/mimic_cxr_image/manifests/solo_600.csv \
-  --image-root ~/mimic-cxr-raw \
-  --out experiments/mimic_cxr_image/results --n 600
+Point the dataset-agnostic imaging runners at the per-arm manifests. `--n 9999` means "every image
+in this arm" (the runners cap at the manifest size, so a smaller `--n` would silently truncate).
+Each run caches per call, so an interrupted run resumes cheaply on re-run.
 
-# #311 cascade -> cascade_150.csv ; #315 referee -> referee_300.csv ;
-# #314 blind-metric -> blind_metric_100.csv ; #312 system-flag, #313 cue-strength -> solo_600.csv
+```bash
+M=experiments/mimic_cxr_image/manifests ; O=experiments/mimic_cxr_image/results ; RAW=~/mimic-cxr-raw
+
+python -m experiments.imaging.imaging_solo             --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999   # #310
+python -m experiments.imaging.imaging_cascade          --manifest $M/cascade_150.csv      --image-root $RAW --out $O --n 9999   # #311
+python -m experiments.imaging.imaging_system_flag      --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999   # #312
+python -m experiments.imaging.imaging_strength_cascade --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999   # #313
+python -m experiments.imaging.imaging_blind_metric     --manifest $M/blind_metric_100.csv --image-root $RAW --out $O --n 9999   # #314
+
+# #315 referee consumes a cascade transcript over referee_300: run the cascade first, then pass the
+# transcript jsonl it writes in $O (confirm the exact name with `--help`).
+python -m experiments.imaging.imaging_cascade          --manifest $M/referee_300.csv      --image-root $RAW --out $O --n 9999
+python -m experiments.imaging.imaging_referee          --manifest $M/referee_300.csv      --image-root $RAW --cascade-jsonl $O/<cascade_output>.jsonl --out $O
 ```
 
 Results land under `experiments/mimic_cxr_image/results/`, same format as

From b8b49055092da2acf5c4403a289154ee6c5f1dea Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Sat, 25 Jul 2026 10:27:24 +0200
Subject: [PATCH 3/7] docs: give each MIMIC-CXR cascade run its own --out (fix
 collision)

The watermark cue makes imaging_cascade write a fixed imaging_cascade.jsonl,
so running the #311 (cascade_150) and referee-prep (referee_300) cascades into
one --out silently overwrote the #311 arm. Route each to its own subdir and
wire the referee at the referee_300 transcript.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 experiments/mimic_cxr_image/README.md | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/experiments/mimic_cxr_image/README.md b/experiments/mimic_cxr_image/README.md
index 1eb9125..d6a2f83 100644
--- a/experiments/mimic_cxr_image/README.md
+++ b/experiments/mimic_cxr_image/README.md
@@ -99,16 +99,17 @@ Each run caches per call, so an interrupted run resumes cheaply on re-run.
 ```bash
 M=experiments/mimic_cxr_image/manifests ; O=experiments/mimic_cxr_image/results ; RAW=~/mimic-cxr-raw
 
-python -m experiments.imaging.imaging_solo             --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999   # #310
-python -m experiments.imaging.imaging_cascade          --manifest $M/cascade_150.csv      --image-root $RAW --out $O --n 9999   # #311
-python -m experiments.imaging.imaging_system_flag      --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999   # #312
-python -m experiments.imaging.imaging_strength_cascade --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999   # #313
-python -m experiments.imaging.imaging_blind_metric     --manifest $M/blind_metric_100.csv --image-root $RAW --out $O --n 9999   # #314
-
-# #315 referee consumes a cascade transcript over referee_300: run the cascade first, then pass the
-# transcript jsonl it writes in $O (confirm the exact name with `--help`).
-python -m experiments.imaging.imaging_cascade          --manifest $M/referee_300.csv      --image-root $RAW --out $O --n 9999
-python -m experiments.imaging.imaging_referee          --manifest $M/referee_300.csv      --image-root $RAW --cascade-jsonl $O/<cascade_output>.jsonl --out $O
+python -m experiments.imaging.imaging_solo             --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999               # #310
+python -m experiments.imaging.imaging_cascade          --manifest $M/cascade_150.csv      --image-root $RAW --out $O/cascade_150 --n 9999   # #311
+python -m experiments.imaging.imaging_system_flag      --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999               # #312
+python -m experiments.imaging.imaging_strength_cascade --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999               # #313
+python -m experiments.imaging.imaging_blind_metric     --manifest $M/blind_metric_100.csv --image-root $RAW --out $O --n 9999               # #314
+
+# #315 referee consumes a cascade transcript over referee_300. Give each cascade run its OWN --out:
+# for the watermark cue imaging_cascade writes a fixed imaging_cascade.jsonl, so a shared --out would
+# silently overwrite the #311 arm. Run the referee_300 cascade into its own dir, then run the referee.
+python -m experiments.imaging.imaging_cascade          --manifest $M/referee_300.csv      --image-root $RAW --out $O/referee_300 --n 9999
+python -m experiments.imaging.imaging_referee          --manifest $M/referee_300.csv      --image-root $RAW --cascade-jsonl $O/referee_300/imaging_cascade.jsonl --out $O/referee_300
 ```
 
 Results land under `experiments/mimic_cxr_image/results/`, same format as

From c853a393c4f5b37f9bee0bbc5ef81aaf5811d59d Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Sat, 25 Jul 2026 10:30:36 +0200
Subject: [PATCH 4/7] results: MIMIC-CXR imaging battery summaries (#92, #295)

Aggregate per-arm summaries for the six-arm battery on the seed-20240724 subset:
solo (#310), cascade_150 (#311), system_flag (#312), strength_cascade (#313),
blind_metric (#314), referee_300 cascade + referee (#315).

Per-case *.jsonl transcripts, caches, and run logs are gitignored: they link
MIMIC case_ids to reads (credentialed-data caution) and regenerate from the runners.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 experiments/mimic_cxr_image/.gitignore        |  6 ++++
 .../cascade_150/imaging_cascade_summary.json  |  9 ++++++
 .../results/imaging_blind_metric_summary.json | 17 +++++++++++
 .../results/imaging_solo_summary.json         | 28 +++++++++++++++++++
 .../imaging_strength_cascade_summary.json     | 27 ++++++++++++++++++
 .../results/imaging_system_flag_summary.json  | 27 ++++++++++++++++++
 .../referee_300/imaging_cascade_summary.json  |  9 ++++++
 .../referee_300/imaging_referee_summary.json  | 25 +++++++++++++++++
 8 files changed, 148 insertions(+)
 create mode 100644 experiments/mimic_cxr_image/results/cascade_150/imaging_cascade_summary.json
 create mode 100644 experiments/mimic_cxr_image/results/imaging_blind_metric_summary.json
 create mode 100644 experiments/mimic_cxr_image/results/imaging_solo_summary.json
 create mode 100644 experiments/mimic_cxr_image/results/imaging_strength_cascade_summary.json
 create mode 100644 experiments/mimic_cxr_image/results/imaging_system_flag_summary.json
 create mode 100644 experiments/mimic_cxr_image/results/referee_300/imaging_cascade_summary.json
 create mode 100644 experiments/mimic_cxr_image/results/referee_300/imaging_referee_summary.json

diff --git a/experiments/mimic_cxr_image/.gitignore b/experiments/mimic_cxr_image/.gitignore
index 734d4e9..509a733 100644
--- a/experiments/mimic_cxr_image/.gitignore
+++ b/experiments/mimic_cxr_image/.gitignore
@@ -3,3 +3,9 @@
 manifests/*.csv
 manifests/download_list.txt
 manifests/provenance.json
+
+# Experiment results: commit the aggregate *_summary.json only. The per-case *.jsonl transcripts
+# and caches link MIMIC case_ids to reads (same credentialed-data caution as the manifests) and
+# regenerate from the runners; run logs reference host paths.
+results/**/*.jsonl
+results/**/*.log
diff --git a/experiments/mimic_cxr_image/results/cascade_150/imaging_cascade_summary.json b/experiments/mimic_cxr_image/results/cascade_150/imaging_cascade_summary.json
new file mode 100644
index 0000000..10c7d3d
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/cascade_150/imaging_cascade_summary.json
@@ -0,0 +1,9 @@
+{
+  "n": 215,
+  "model": "gemini-2.5-flash",
+  "cue": "watermark",
+  "new_api_calls_this_run": 645,
+  "shared_adopt": 0.9953,
+  "isolated_adopt": 0.1767,
+  "contagion": 0.8186
+}
\ No newline at end of file
diff --git a/experiments/mimic_cxr_image/results/imaging_blind_metric_summary.json b/experiments/mimic_cxr_image/results/imaging_blind_metric_summary.json
new file mode 100644
index 0000000..e128ba5
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/imaging_blind_metric_summary.json
@@ -0,0 +1,17 @@
+{
+  "n": 141,
+  "model": "gemini-2.5-flash",
+  "new_api_calls_this_run": 282,
+  "decoy_uptake": {
+    "baseline": 0.0,
+    "blind": 0.5532,
+    "test_aware": 0.2624
+  },
+  "decoy_uptake_delta_blind_minus_baseline": 0.5532,
+  "test_awareness_suppression_delta_blind_minus_aware": 0.2908,
+  "naming_vs_drifting": {
+    "n_drifted": 78,
+    "n_named_rubric": 0,
+    "n_drifted_silently": 78
+  }
+}
\ No newline at end of file
diff --git a/experiments/mimic_cxr_image/results/imaging_solo_summary.json b/experiments/mimic_cxr_image/results/imaging_solo_summary.json
new file mode 100644
index 0000000..02fa9c0
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/imaging_solo_summary.json
@@ -0,0 +1,28 @@
+{
+  "n": 834,
+  "model": "gemini-2.5-flash",
+  "cues": {
+    "cable": {
+      "flip_rate": 0.2026378896882494,
+      "n": 834,
+      "flip_above_noise": 0.021582733812949617
+    },
+    "corner_tag": {
+      "flip_rate": 0.18585131894484413,
+      "n": 834,
+      "flip_above_noise": 0.0047961630695443624
+    },
+    "watermark": {
+      "flip_rate": 0.17625899280575538,
+      "n": 834,
+      "flip_above_noise": -0.00479616306954439
+    },
+    "laterality": {
+      "flip_rate": 0.17146282973621102,
+      "n": 834,
+      "flip_above_noise": -0.009592326139088753
+    }
+  },
+  "noise_floor": 0.18105515587529977,
+  "noise_floor_n": 834
+}
\ No newline at end of file
diff --git a/experiments/mimic_cxr_image/results/imaging_strength_cascade_summary.json b/experiments/mimic_cxr_image/results/imaging_strength_cascade_summary.json
new file mode 100644
index 0000000..31e2796
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/imaging_strength_cascade_summary.json
@@ -0,0 +1,27 @@
+{
+  "n": 834,
+  "model": "gemini-2.5-flash",
+  "cue": "watermark",
+  "new_api_calls_this_run": 5837,
+  "strength_x_cascade": {
+    "opacity_0.15": {
+      "solo_flip": 0.2026,
+      "iso_adopt": 0.2026,
+      "shared_adopt": 1.0,
+      "contagion": 0.7974
+    },
+    "opacity_0.3": {
+      "solo_flip": 0.1918,
+      "iso_adopt": 0.1918,
+      "shared_adopt": 1.0,
+      "contagion": 0.8082
+    },
+    "opacity_0.45": {
+      "solo_flip": 0.2026,
+      "iso_adopt": 0.2026,
+      "shared_adopt": 0.9976,
+      "contagion": 0.795
+    }
+  },
+  "read": "Watermark cue swept across opacity 0.15 / 0.30 / 0.45, each crossed with solo vs committee: {'opacity_0.15': {'solo_flip': 0.2026, 'iso_adopt': 0.2026, 'shared_adopt': 1.0, 'contagion': 0.7974}, 'opacity_0.3': {'solo_flip': 0.1918, 'iso_adopt': 0.1918, 'shared_adopt': 1.0, 'contagion': 0.8082}, 'opacity_0.45': {'solo_flip': 0.2026, 'iso_adopt': 0.2026, 'shared_adopt': 0.9976, 'contagion': 0.795}}. If solo_flip rises with opacity the stimulus strength knob works; if contagion (shared minus isolated) ALSO rises with opacity a stronger solo cue cascades more, whereas a flat, large contagion across opacities means the confident wrong peer dominates and stimulus strength barely matters once a peer is on the board."
+}
\ No newline at end of file
diff --git a/experiments/mimic_cxr_image/results/imaging_system_flag_summary.json b/experiments/mimic_cxr_image/results/imaging_system_flag_summary.json
new file mode 100644
index 0000000..dbfe092
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/imaging_system_flag_summary.json
@@ -0,0 +1,27 @@
+{
+  "n": 834,
+  "model": "gemini-2.5-flash",
+  "cue": "watermark",
+  "board": "automated_system_flag",
+  "new_api_calls_this_run": 2072,
+  "shared_adopt": 0.4029,
+  "isolated_adopt": 0.2026,
+  "contagion": 0.2002,
+  "shared_vs_isolated_mcnemar": {
+    "gain": 210,
+    "lose": 43,
+    "pvalue": 0.0
+  },
+  "vs_peer_assertion_cascade": {
+    "system_flag_shared_adopt_k_of_n": [
+      336,
+      834
+    ],
+    "peer_assertion_shared_adopt_k_of_n": [
+      214,
+      215
+    ],
+    "fisher_pvalue": 0.0,
+    "fisher_oddsratio": 0.0032
+  }
+}
\ No newline at end of file
diff --git a/experiments/mimic_cxr_image/results/referee_300/imaging_cascade_summary.json b/experiments/mimic_cxr_image/results/referee_300/imaging_cascade_summary.json
new file mode 100644
index 0000000..2d9a199
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/referee_300/imaging_cascade_summary.json
@@ -0,0 +1,9 @@
+{
+  "n": 417,
+  "model": "gemini-2.5-flash",
+  "cue": "watermark",
+  "new_api_calls_this_run": 1251,
+  "shared_adopt": 0.9808,
+  "isolated_adopt": 0.1727,
+  "contagion": 0.8082
+}
\ No newline at end of file
diff --git a/experiments/mimic_cxr_image/results/referee_300/imaging_referee_summary.json b/experiments/mimic_cxr_image/results/referee_300/imaging_referee_summary.json
new file mode 100644
index 0000000..56f918f
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/referee_300/imaging_referee_summary.json
@@ -0,0 +1,25 @@
+{
+  "n": 417,
+  "model": "gemini-2.5-flash",
+  "cue": "watermark",
+  "new_api_calls_this_run": 349,
+  "peer_driven_adoptions_gt": 337,
+  "referee": {
+    "tp": 272,
+    "fp": 35,
+    "fn": 65,
+    "tn": 45,
+    "precision": 0.8859934853420195,
+    "recall": 0.8071216617210683,
+    "fpr": 0.4375
+  },
+  "naive_gate": {
+    "tp": 337,
+    "fp": 72,
+    "fn": 0,
+    "tn": 8,
+    "precision": 0.823960880195599,
+    "recall": 1.0,
+    "fpr": 0.9
+  }
+}
\ No newline at end of file

From 6834113247790b632c6ac50d803c2f1dc1b389dd Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Sat, 25 Jul 2026 10:40:03 +0200
Subject: [PATCH 5/7] results: matched 35-study MIMIC solo for the NIH-vs-MIMIC
 cell (#295)

Solo on the nih_match_35 arm (35 studies / 50 images): flip above noise ~0 for
every cue (watermark -0.04, noise floor 0.18), confirming the full 834-image
solo result at the matched-to-NIH size.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../nih_match_35/imaging_solo_summary.json    | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json

diff --git a/experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json b/experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json
new file mode 100644
index 0000000..9d47903
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json
@@ -0,0 +1,28 @@
+{
+  "n": 50,
+  "model": "gemini-2.5-flash",
+  "cues": {
+    "cable": {
+      "flip_rate": 0.16,
+      "n": 50,
+      "flip_above_noise": -0.01999999999999999
+    },
+    "corner_tag": {
+      "flip_rate": 0.18,
+      "n": 50,
+      "flip_above_noise": 0.0
+    },
+    "watermark": {
+      "flip_rate": 0.14,
+      "n": 50,
+      "flip_above_noise": -0.03999999999999998
+    },
+    "laterality": {
+      "flip_rate": 0.18,
+      "n": 50,
+      "flip_above_noise": 0.0
+    }
+  },
+  "noise_floor": 0.18,
+  "noise_floor_n": 50
+}
\ No newline at end of file

From 7c96429a26ad33b012d67592f7508e92c9678bb6 Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Mon, 27 Jul 2026 12:52:37 +0200
Subject: [PATCH 6/7] reanalysis: plant-direction split for MIMIC
 cascade-family arms (#332, #339)

Offline split of the committed transcripts into genuinely-false (wrong==no,
the honest harmful-sycophancy measure) vs planted-truth (wrong==yes). On MIMIC
~80% of finding-present cases plant the truth (poor pneumothorax clean reads),
so ALL contagion is inflated:

- cascade_150 (#311): ALL +0.82 -> genuinely-false +0.49
- referee_300 cascade: ALL +0.81 -> +0.51
- strength_cascade (#313): ALL ~+0.80 -> ~+0.53-0.55 (flat across opacity)
- system_flag (#312): robust, +0.225 ~ ALL +0.200

Qualitative conclusions unchanged. No API/network; reads transcripts only.
imaging_cascade fixed on main (#333); system_flag/strength_cascade tracked in #339.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../mimic_cxr_image/plant_direction_check.py  | 85 +++++++++++++++++
 .../results/plant_direction_summary.json      | 94 +++++++++++++++++++
 2 files changed, 179 insertions(+)
 create mode 100644 experiments/mimic_cxr_image/plant_direction_check.py
 create mode 100644 experiments/mimic_cxr_image/results/plant_direction_summary.json

diff --git a/experiments/mimic_cxr_image/plant_direction_check.py b/experiments/mimic_cxr_image/plant_direction_check.py
new file mode 100644
index 0000000..5662367
--- /dev/null
+++ b/experiments/mimic_cxr_image/plant_direction_check.py
@@ -0,0 +1,85 @@
+"""Plant-direction reanalysis for the MIMIC-CXR cascade-family arms (#332 / #339).
+
+The shared imaging-cascade family planted ``wrong = flip(clean_read)`` rather than against ground
+truth, so on cases where the model's clean read is already wrong the planted read is actually the
+truth and the committee merely corrects the holdout instead of being led astray. This offline
+reanalysis of the committed transcripts splits each arm's contagion (shared_adopt - iso_adopt) into
+the genuinely-false subgroup (``wrong == "no"`` -- the honest harmful-sycophancy measure) vs
+planted-truth (``wrong == "yes"``). No API and no network: it only reads the transcript JSONL.
+
+On MIMIC ~80% of finding-present cases plant the truth (gemini-2.5-flash reads pneumothorax poorly,
+so its clean read is already wrong), which inflates the ALL contagion; the genuinely-false subgroup
+is the honest number. imaging_cascade.py is fixed on main (#333); imaging_system_flag.py and
+imaging_strength_cascade.py still carry the buggy plant (tracked in #339), which is why their MIMIC
+transcripts are re-analysed here rather than re-run.
+
+Run from the repo root after the battery has produced transcripts under ``results/``:
+
+    python -m experiments.mimic_cxr_image.plant_direction_check
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+RESULTS = Path(__file__).resolve().parent / "results"
+
+
+def _rows(path: Path, need: str) -> list[dict]:
+    if not path.is_file():
+        return []
+    return [json.loads(line) for line in path.read_text().splitlines() if line.strip() and need in line]
+
+
+def _contagion(rows: list[dict], shared_key: str, iso_key: str):
+    if not rows:
+        return {"contagion": None, "n": 0}
+    shared = sum(r[shared_key] for r in rows) / len(rows)
+    iso = sum(r[iso_key] for r in rows) / len(rows)
+    return {"contagion": round(shared - iso, 4), "n": len(rows)}
+
+
+def _split(rows: list[dict], wrong_key: str, shared_key: str, iso_key: str) -> dict:
+    genuinely_false = [r for r in rows if r.get(wrong_key) == "no"]
+    planted_truth = [r for r in rows if r.get(wrong_key) == "yes"]
+    total = len(rows) or 1
+    return {
+        "all": _contagion(rows, shared_key, iso_key),
+        "genuinely_false": _contagion(genuinely_false, shared_key, iso_key),
+        "planted_truth": _contagion(planted_truth, shared_key, iso_key),
+        "pct_planted_truth": round(100 * len(planted_truth) / total, 1),
+    }
+
+
+def analyze(results: Path = RESULTS) -> dict:
+    """Split every available cascade-family MIMIC arm; skips arms whose transcript is absent."""
+    out: dict = {}
+
+    for arm, rel in (("cascade_150", "cascade_150/imaging_cascade.jsonl"),
+                     ("referee_300_cascade", "referee_300/imaging_cascade.jsonl"),
+                     ("system_flag", "imaging_system_flag.jsonl")):
+        rows = _rows(results / rel, "shared_adopt")
+        if rows:
+            out[arm] = _split(rows, "wrong", "shared_adopt", "iso_adopt")
+
+    strength = _rows(results / "imaging_strength_cascade.jsonl", "planted_wrong")
+    if strength:
+        out["strength_cascade"] = {
+            f"opacity_{op}": _split(strength, "planted_wrong", f"op{op}_shared_adopt", f"op{op}_iso_adopt")
+            for op in ("0.15", "0.3", "0.45")
+        }
+
+    return out
+
+
+def main() -> None:
+    res = analyze()
+    if not res:
+        raise SystemExit(f"no cascade-family transcripts found under {RESULTS} (run the battery first)")
+    (RESULTS / "plant_direction_summary.json").write_text(json.dumps(res, indent=2), encoding="utf-8")
+    print(json.dumps(res, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/experiments/mimic_cxr_image/results/plant_direction_summary.json b/experiments/mimic_cxr_image/results/plant_direction_summary.json
new file mode 100644
index 0000000..c203f7a
--- /dev/null
+++ b/experiments/mimic_cxr_image/results/plant_direction_summary.json
@@ -0,0 +1,94 @@
+{
+  "cascade_150": {
+    "all": {
+      "contagion": 0.8186,
+      "n": 215
+    },
+    "genuinely_false": {
+      "contagion": 0.4884,
+      "n": 43
+    },
+    "planted_truth": {
+      "contagion": 0.9012,
+      "n": 172
+    },
+    "pct_planted_truth": 80.0
+  },
+  "referee_300_cascade": {
+    "all": {
+      "contagion": 0.8082,
+      "n": 417
+    },
+    "genuinely_false": {
+      "contagion": 0.5057,
+      "n": 87
+    },
+    "planted_truth": {
+      "contagion": 0.8879,
+      "n": 330
+    },
+    "pct_planted_truth": 79.1
+  },
+  "system_flag": {
+    "all": {
+      "contagion": 0.2002,
+      "n": 834
+    },
+    "genuinely_false": {
+      "contagion": 0.2249,
+      "n": 169
+    },
+    "planted_truth": {
+      "contagion": 0.194,
+      "n": 665
+    },
+    "pct_planted_truth": 79.7
+  },
+  "strength_cascade": {
+    "opacity_0.15": {
+      "all": {
+        "contagion": 0.7974,
+        "n": 834
+      },
+      "genuinely_false": {
+        "contagion": 0.5475,
+        "n": 179
+      },
+      "planted_truth": {
+        "contagion": 0.8656,
+        "n": 655
+      },
+      "pct_planted_truth": 78.5
+    },
+    "opacity_0.3": {
+      "all": {
+        "contagion": 0.8082,
+        "n": 834
+      },
+      "genuinely_false": {
+        "contagion": 0.5307,
+        "n": 179
+      },
+      "planted_truth": {
+        "contagion": 0.884,
+        "n": 655
+      },
+      "pct_planted_truth": 78.5
+    },
+    "opacity_0.45": {
+      "all": {
+        "contagion": 0.795,
+        "n": 834
+      },
+      "genuinely_false": {
+        "contagion": 0.5531,
+        "n": 179
+      },
+      "planted_truth": {
+        "contagion": 0.8611,
+        "n": 655
+      },
+      "pct_planted_truth": 78.5
+    }
+  }
+}
\ No newline at end of file

From d3331d085189cb4e64c8d23b5f22f59fbf00169e Mon Sep 17 00:00:00 2001
From: amarzullo24 <marzullo.aldo24@gmail.com>
Date: Wed, 29 Jul 2026 10:10:24 +0200
Subject: [PATCH 7/7] fix(#329): size nih_match by image count, not studies (35
 images)

Reviewers (Agastya, sebasmos, maximinl) flagged the matched-to-NIH arm shipped
50 images (35 studies x all views) vs NIH's n=35 one-image-per-case, so the
cross-dataset cell was 50-vs-35 and averaged over correlated multi-view clusters.

- build_subset.py: IMAGE_SIZED_ARMS={'nih_match'}; the arm now takes the first N
  images in study-rank order (exactly 35), still a prefix of the ranking so it
  nests inside the study-sized arms (verified on real data: nih<blind<cascade<referee<solo).
- selection_summary.json: nih_match now studies:26, images:35.
- test_mimic_subset.py: split study-level nesting from a dedicated image-sizing
  + determinism test.
- README section 4: add the nih_match_35 imaging_solo invocation (Agastya's note),
  so the recipe regenerates all six arms.
- Remove the stale n=50 nih_match solo summary; it regenerates on the real-data
  rerun (35 images, a cached subset of solo_600 + noise floor).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 experiments/mimic_cxr_image/README.md         |  1 +
 experiments/mimic_cxr_image/build_subset.py   | 23 +++++++++++++--
 .../manifests/selection_summary.json          |  4 +--
 .../nih_match_35/imaging_solo_summary.json    | 28 -------------------
 tests/test_mimic_subset.py                    | 28 ++++++++++++++++---
 5 files changed, 47 insertions(+), 37 deletions(-)
 delete mode 100644 experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json

diff --git a/experiments/mimic_cxr_image/README.md b/experiments/mimic_cxr_image/README.md
index d6a2f83..40a6a89 100644
--- a/experiments/mimic_cxr_image/README.md
+++ b/experiments/mimic_cxr_image/README.md
@@ -100,6 +100,7 @@ Each run caches per call, so an interrupted run resumes cheaply on re-run.
 M=experiments/mimic_cxr_image/manifests ; O=experiments/mimic_cxr_image/results ; RAW=~/mimic-cxr-raw
 
 python -m experiments.imaging.imaging_solo             --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999               # #310
+python -m experiments.imaging.imaging_solo             --manifest $M/nih_match_35.csv     --image-root $RAW --out $O/nih_match_35 --n 9999  # NIH-matched (35 images)
 python -m experiments.imaging.imaging_cascade          --manifest $M/cascade_150.csv      --image-root $RAW --out $O/cascade_150 --n 9999   # #311
 python -m experiments.imaging.imaging_system_flag      --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999               # #312
 python -m experiments.imaging.imaging_strength_cascade --manifest $M/solo_600.csv         --image-root $RAW --out $O --n 9999               # #313
diff --git a/experiments/mimic_cxr_image/build_subset.py b/experiments/mimic_cxr_image/build_subset.py
index aa23e06..1316e12 100644
--- a/experiments/mimic_cxr_image/build_subset.py
+++ b/experiments/mimic_cxr_image/build_subset.py
@@ -45,9 +45,14 @@
     "referee": 300,
     "cascade": 150,
     "blind_metric": 100,
-    "nih_match": 35,
+    "nih_match": 35,  # IMAGES, not studies (see IMAGE_SIZED_ARMS): matched one-per-observation to NIH n=35
 }
 
+# Arms sized by image count rather than study count. nih_match is the matched-to-NIH cell: NIH runs
+# one image per case, so counting studies here (each expanded to all its views) would ship correlated
+# multi-view clusters and a mismatched n. Sizing by images keeps it exactly n one-per-observation.
+IMAGE_SIZED_ARMS = frozenset({"nih_match"})
+
 DEFAULT_URL_BASE = "https://physionet.org/files/mimic-cxr-jpg/2.1.0/"
 
 
@@ -71,6 +76,11 @@ def select_arms(cases, seed: int, sizes: dict[str, int], require_finding: bool =
     with the same seed, the smaller arms are strict subsets of the larger ones: the top-100 studies
     are a prefix of the top-300, which are a prefix of the top-600 (the prefix property of
     :func:`subsample_cases`). Returns ``{arm_name: [Case, ...]}``.
+
+    Arms in :data:`IMAGE_SIZED_ARMS` (``nih_match``) are instead sized by image count: the first N
+    images in study-rank order, so the matched-to-NIH cell is n images one-per-observation rather
+    than N studies expanded to more (correlated) views. It stays a prefix of the ranking, so it
+    still nests inside the study-sized arms.
     """
     eligible = [c for c in cases if not require_finding or _is_finding(c)]
     studies: dict[str, list] = {}
@@ -80,8 +90,15 @@ def select_arms(cases, seed: int, sizes: dict[str, int], require_finding: bool =
 
     arms: dict[str, list] = {}
     for arm, n in sizes.items():
-        picked = subsample_cases(study_keys, RunBudget(max_cases=n, seed=seed))
-        arms[arm] = [case for key in picked for case in studies[key]]
+        if arm in IMAGE_SIZED_ARMS:
+            # Rank studies, then take the first n images in that order. Ranking n studies always
+            # yields >= n images (each study has >= 1 image), and the slice is a prefix of the study
+            # ranking, so the arm still nests inside the study-sized arms.
+            picked = subsample_cases(study_keys, RunBudget(max_cases=min(n, len(study_keys)), seed=seed))
+            arms[arm] = [case for key in picked for case in studies[key]][:n]
+        else:
+            picked = subsample_cases(study_keys, RunBudget(max_cases=n, seed=seed))
+            arms[arm] = [case for key in picked for case in studies[key]]
     return arms
 
 
diff --git a/experiments/mimic_cxr_image/manifests/selection_summary.json b/experiments/mimic_cxr_image/manifests/selection_summary.json
index 9d1d389..a4ae514 100644
--- a/experiments/mimic_cxr_image/manifests/selection_summary.json
+++ b/experiments/mimic_cxr_image/manifests/selection_summary.json
@@ -30,8 +30,8 @@
     },
     "nih_match": {
       "manifest": "experiments/mimic_cxr_image/manifests/nih_match_35.csv",
-      "studies": 35,
-      "images": 50
+      "studies": 26,
+      "images": 35
     }
   },
   "download_list": "experiments/mimic_cxr_image/manifests/download_list.txt",
diff --git a/experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json b/experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json
deleted file mode 100644
index 9d47903..0000000
--- a/experiments/mimic_cxr_image/results/nih_match_35/imaging_solo_summary.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "n": 50,
-  "model": "gemini-2.5-flash",
-  "cues": {
-    "cable": {
-      "flip_rate": 0.16,
-      "n": 50,
-      "flip_above_noise": -0.01999999999999999
-    },
-    "corner_tag": {
-      "flip_rate": 0.18,
-      "n": 50,
-      "flip_above_noise": 0.0
-    },
-    "watermark": {
-      "flip_rate": 0.14,
-      "n": 50,
-      "flip_above_noise": -0.03999999999999998
-    },
-    "laterality": {
-      "flip_rate": 0.18,
-      "n": 50,
-      "flip_above_noise": 0.0
-    }
-  },
-  "noise_floor": 0.18,
-  "noise_floor_n": 50
-}
\ No newline at end of file
diff --git a/tests/test_mimic_subset.py b/tests/test_mimic_subset.py
index a7f1fd8..735f6e9 100644
--- a/tests/test_mimic_subset.py
+++ b/tests/test_mimic_subset.py
@@ -35,11 +35,31 @@ def _study_set(cases):
 def test_smaller_arms_are_strict_subsets_of_larger_ones():
     # The whole point of one seed: blind < cascade < referee < solo must nest at study level.
     cases = _pool(50)
-    sizes = {"solo": 30, "referee": 20, "cascade": 10, "nih_match": 5}
+    sizes = {"solo": 30, "referee": 20, "cascade": 10}
     arms = select_arms(cases, seed=7, sizes=sizes)
-    solo, referee, cascade, nih = map(_study_set, (arms["solo"], arms["referee"], arms["cascade"], arms["nih_match"]))
-    assert nih < cascade < referee < solo
-    assert len(solo) == 30 and len(nih) == 5
+    solo, referee, cascade = map(_study_set, (arms["solo"], arms["referee"], arms["cascade"]))
+    assert cascade < referee < solo
+    assert len(solo) == 30
+
+
+def test_nih_match_is_sized_by_image_count_and_nests():
+    # nih_match matches NIH's one-image-per-observation shape: sized by IMAGE count, not studies.
+    # 2 images/study, so 5 studies would be 10 images; image-sizing must give exactly 5 images.
+    cases = _pool(50, images_per_study=2)
+    arms = select_arms(cases, seed=7, sizes={"cascade": 10, "nih_match": 5})
+    nih = arms["nih_match"]
+    assert len(nih) == 5                                  # exactly 5 images, not 5 studies (=10 images)
+    assert len(_study_set(nih)) <= 3                      # 5 images span a prefix of ranked studies
+    assert _study_set(nih) < _study_set(arms["cascade"])  # still nests inside the study-sized arm
+
+
+def test_nih_match_is_deterministic_and_odd_image_counts_are_exact():
+    # Exact n even when the walk would overshoot a multi-image study, and stable across runs.
+    cases = _pool(40, images_per_study=3)
+    a = select_arms(cases, seed=2, sizes={"nih_match": 7})["nih_match"]
+    b = select_arms(cases, seed=2, sizes={"nih_match": 7})["nih_match"]
+    assert len(a) == 7
+    assert [c.case_id for c in a] == [c.case_id for c in b]
 
 
 def test_all_images_of_a_selected_study_are_kept():