Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/fold_sizes.py

@@ -0,0 +1,34 @@
+"""Shared wording for the 5-fold "every training donor" arm (2026-10-02).
+
+The deck used to call this arm "all" / "all training pairs", which reads as if test pairs were used. They never are:
+each fold's LoRA trains on the other four folds minus 7-8 inner-validation donors, and its RUN.json lists the test rows
+as "test_rows_never_loaded_for_training". Every figure now shows the actual number of training pairs instead.
+"""
+import json
+from functools import lru_cache
+from pathlib import Path
+
+PLAN = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+            "paired_finetune_intradataset_20260927")
+FOLD_ARM_LABEL = "5-fold CV (other 4 folds)"          # arm suffix, e.g. "LoRA, 5-fold CV (other 4 folds)"
+FOLD_TITLE = "5-fold CV: train on the other 4 folds"
+FOLD_NOTE = "each fold model trains on the other 4 folds (minus inner-val); its test fold is never trained on"
+
+
+@lru_cache(maxsize=None)
+def train_pairs(ds: str, run: str = "real_lora") -> tuple[int, int]:
+    """(min, max) training pairs per fold of the 5-fold LoRA run, from runs/<ds>/fold<k>/<run>/RUN.json."""
+    n = []
+    for k in range(5):
+        r = json.loads((PLAN / "runs" / ds / f"fold{k}" / run / "RUN.json").read_text())
+        tr, te = r["train_rows"], r["test_rows_never_loaded_for_training"]
+        if set(tr) & set(te):
+            raise SystemExit(f"{ds} fold {k}: train and test rows overlap")
+        n.append(len(tr))
+    return min(n), max(n)
+
+
+def all_label(ds: str) -> str:
+    """Tick label for the 'every training donor' point: '78–79' (ImMicro), '58–59' (sepsis)."""
+    lo, hi = train_pairs(ds)
+    return f"{lo}" if lo == hi else f"{lo}–{hi}"

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/restructure_20261002.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""One-off restructure of data/slides_spec.json (2026-10-02, user request): no Backup section.
+
+The backup slides move into the sections they support, a metric-overview slide opens section 4, and every slide that
+uses a published method, metric or baseline gets a one-line reference footer (short citations; full citations with
+DOI in the speaker notes). Slide content (titles, keywords, footnotes) is left to the section scripts and
+tools/sync_sec09_text.py; this script only orders slides, sets section labels, the agenda and the references.
+Run once on the pre-restructure spec (it refuses to run twice). The pre-restructure spec is in
+_archive/2026-10-02_before_restructure/.
+"""
+import json
+import sys
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = DECK / "data" / "slides_spec.json"
+
+# short citation for the footer, full citation for the notes (verified 2026-10-02; PDFs in reference-papers/)
+REF = {
+    "SDD": ("Ostheimer 2025, arXiv", "Ostheimer et al. Sparse Data Diffusion for scientific simulations in biology and physics. arXiv:2502.02448 (2025)"),
+    "DDIM": ("Song 2021, ICLR", "Song, Meng & Ermon. Denoising Diffusion Implicit Models. ICLR 2021"),
+    "scDiffusion": ("Luo 2024, Bioinformatics", "Luo et al. scDiffusion: conditional generation of high-quality single-cell data using diffusion model. Bioinformatics 40(9):btae518 (2024)"),
+    "scSemi": ("Wang 2024, Nat Commun", "Wang et al. scSemiProfiler: advancing large-scale single-cell studies through semi-profiling with deep generative models and active learning. Nat Commun 15:5989 (2024). doi:10.1038/s41467-024-50150-1"),
+    "scANVI": ("Xu 2021, Mol Syst Biol", "Xu et al. Probabilistic harmonization and annotation of single-cell transcriptomics data with deep generative models. Mol Syst Biol 17:e9620 (2021)"),
+    "LoRA": ("Hu 2022, ICLR", "Hu et al. LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022"),
+    "Kyn": ("Kynkäänniemi 2019, NeurIPS", "Kynkäänniemi et al. Improved precision and recall metric for assessing generative models. NeurIPS 2019"),
+    "Naeem": ("Naeem 2020, ICML", "Naeem et al. Reliable fidelity and diversity metrics for generative models. ICML 2020"),
+    "Khayat": ("Khayatkhoei 2023, ICML", "Khayatkhoei & AbdAlmageed. Emergent asymmetry of precision and recall for measuring fidelity and diversity of generative models in high dimensions. ICML 2023"),
+    "LopezPaz": ("Lopez-Paz 2017, ICLR", "Lopez-Paz & Oquab. Revisiting classifier two-sample tests. ICLR 2017"),
+    "Gretton": ("Gretton 2012, JMLR", "Gretton et al. A kernel two-sample test. JMLR 13:723-773 (2012)"),
+    "GEARS": ("Roohani 2024, Nat Biotechnol", "Roohani, Huang & Leskovec. Predicting transcriptional outcomes of novel multigene perturbations with GEARS. Nat Biotechnol 42:927-935 (2024). doi:10.1038/s41587-023-01905-6"),
+    "Systema": ("Viñas Torné 2026, Nat Biotechnol", "Viñas Torné et al. Systema: a framework for evaluating genetic perturbation response prediction beyond systematic variation. Nat Biotechnol 44:1050-1059 (2026). doi:10.1038/s41587-025-02777-8"),
+    "AhlmannEltze": ("Ahlmann-Eltze 2025, Nat Methods", "Ahlmann-Eltze, Huber & Anders. Deep-learning-based gene perturbation effect prediction does not yet outperform simple linear baselines. Nat Methods 22:1657-1661 (2025). doi:10.1038/s41592-025-02772-6"),
+    "Li2026": ("Li 2026, Sci Adv", "Li et al. A systematic comparison of single-cell perturbation response prediction models. Sci Adv 12:eaed3414 (2026). doi:10.1126/sciadv.aed3414"),
+    "Squair": ("Squair 2021, Nat Commun", "Squair et al. Confronting false discoveries in single-cell differential expression. Nat Commun 12:5692 (2021). doi:10.1038/s41467-021-25960-2"),
+    "voom": ("Law 2014, Genome Biol", "Law, Chen, Shi & Smyth. voom: precision weights unlock linear model analysis tools for RNA-seq read counts. Genome Biol 15:R29 (2014)"),
+    "Irizarry": ("Irizarry 2005, Nat Methods", "Irizarry et al. Multiple-laboratory comparison of microarray platforms. Nat Methods 2:345-350 (2005). doi:10.1038/nmeth756"),
+    "BayesPrism": ("Chu 2022, Nat Cancer", "Chu et al. Cell type and gene expression deconvolution with BayesPrism enables Bayesian integrative analysis across bulk and single-cell RNA sequencing in oncology. Nat Cancer 3:505-517 (2022)"),
+}
+METRIC_REFS = ["Kyn", "Naeem", "LopezPaz", "Gretton", "scSemi", "GEARS", "Systema", "Li2026", "Squair", "voom", "Irizarry"]
+
+AGENDA = [
+    "Model overview: diffusion from bulk to cells",
+    "Backbone: SDD, scDiffusion, bulk conditioning",
+    "Architecture ablation: width, context, gene panel",
+    "How we score cells; SLE benchmark vs scSemiProfiler",
+    "Real bulk ≠ pseudobulk: why zero-shot fails",
+    "Fine-tuning on paired bulk–sc data; evaluation design",
+    "LoRA: compute, rank and K ablations",
+    "How many bulk–sc pairs are needed",
+    "Paired-cohort validation vs scSemiProfiler",
+    "Next: cohorts with a paired subset (planned)",
+]
+SECTION = {"1": "1 Model overview", "2": "2 Backbone", "3": "3 Architecture ablation", "4": "4 Metrics + SLE benchmark",
+           "5": "5 Real bulk vs pseudobulk", "6": "6 Paired fine-tuning", "7": "7 LoRA ablations", "8": "8 Pairs needed",
+           "9": "9 Paired validation", "10": "10 Paired-subset cohorts"}
+METRICS_SLIDE = {
+    "kind": "content", "section": "4", "title": "How we score generated cells", "layout": "full",
+    "figures": ["figures/sec04_metrics_overview.png"],
+    "keywords": ["Cells, composition and disease signal, separately",
+                 "Every metric next to its control or ceiling",
+                 "Same donors and reference cells for every method"],
+    "footnote": "Definitions follow the cited papers; scorers: tools/score_ft.py, extra_metrics.py, contrast_extra.py.",
+    "sources": "tools/sec04_metrics_overview.py; data/sec04_metrics_overview.csv",
+    "refs_full": [REF[k][1] for k in METRIC_REFS],
+}
+# new order: (title, section, refs); the metric slide is inserted by key "METRICS"
+ORDER = [
+    ("PBISC-Diffusion: bulk-to-single-cell generation", None, []),
+    ("Outline", None, []),
+    ("PBISC-Diffusion: bulk in, cells out", "1", ["SDD", "DDIM"]),
+    ("Denoiser: joint value + support diffusion", "1", ["SDD"]),
+    ("Backbone: SDD → PBISC-Diffusion", "2", ["SDD", "scDiffusion"]),
+    ("Bulk conditioning", "2", []),
+    ("Width & context ablation: loss saturation", "3", []),
+    ("Width & context ablation: benchmark", "3", []),
+    ("Gene context: 2k / 3k / 6k / 15k", "3", []),
+    ("METRICS", "4", []),
+    ("SLE benchmark: PBISC vs scSemiProfiler", "4", ["scSemi", "scANVI"]),
+    ("SLE benchmark: per cell type", "4", ["scSemi"]),
+    ("Bulk broadcast baseline", "4", ["Systema", "AhlmannEltze", "BayesPrism"]),
+    ("Real bulk ≠ pseudobulk (model input)", "5", []),
+    ("Same shift in three paired cohorts", "5", []),
+    ("Consequence: cells off-manifold", "5", ["Kyn", "Naeem"]),
+    ("Consequence: disease direction flips", "5", []),
+    ("Fine-tuning with paired bulk + sc", "6", ["LoRA"]),
+    ("Evaluation design", "6", []),
+    ("Full vs LoRA vs cond.-encoder-only", "7", ["LoRA"]),
+    ("LoRA rank: r = 4, 16, 64", "7", ["LoRA"]),
+    ("K diversification: no gain", "7", []),
+    ("Pairs needed: composition, coverage, training steps", "8", ["Kyn", "Naeem"]),
+    ("Pairs needed: donor and disease signal", "8", ["GEARS", "Li2026"]),
+    ("Five paired cohorts", "9", []),
+    ("5 donors: LoRA vs scSemiProfiler — cells", "9", ["Kyn", "Naeem", "scSemi"]),
+    ("5 donors: realism beyond precision/coverage", "9", ["LopezPaz", "Gretton", "scSemi"]),
+    ("5 donors: precision/coverage at k = 3, 5, 10", "9", ["Naeem", "Khayat"]),
+    ("scSemiProfiler copies its representative", "9", ["scSemi"]),
+    ("5 donors: LoRA vs scSemiProfiler — disease signal", "9", ["GEARS", "Systema", "Li2026", "voom", "Irizarry"]),
+    ("5 donors: time to apply", "9", ["scSemi"]),
+    ("5-fold CV: train on the other 4 folds", "9", ["Systema", "Li2026"]),
+    ("5-fold: realism beyond precision/coverage", "9", ["LopezPaz", "Gretton"]),
+    ("Next: cohorts with a paired subset (planned)", "10", []),
+]
+OLD_TITLE = {"5-fold CV: train on the other 4 folds": "All pairs, 5-fold"}
+
+
+def main() -> int:
+    spec = json.loads(SPEC.read_text())
+    sl = spec["slides"]
+    if any(s.get("title") == METRICS_SLIDE["title"] for s in sl):
+        sys.exit("already restructured")
+    by = {s["title"]: s for s in sl}
+    out, used = [], set()
+    for title, sec, refs in ORDER:
+        if title == "METRICS":
+            s = dict(METRICS_SLIDE)
+        else:
+            key = title if title in by else OLD_TITLE.get(title, title)
+            if key not in by:
+                sys.exit(f"slide not found: {title!r}")
+            s = by[key]
+            used.add(key)
+        if sec:
+            s["section"] = sec
+            s["section_label"] = SECTION[sec]
+        s.pop("backup", None)
+        if refs:
+            s["refs"] = [REF[k][0] for k in refs]
+            s["refs_full"] = [REF[k][1] for k in refs]
+        if s.get("kind") == "agenda":
+            s["items"] = AGENDA
+        out.append(s)
+    left = [t for t in by if t not in used and by[t].get("kind") != "divider"]
+    if left:
+        sys.exit(f"slides not placed: {left}")
+    spec["slides"] = out
+    SPEC.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n")
+    print(f"{len(out)} slides (was {len(sl)})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/scsemi_results.py

@@ -0,0 +1,112 @@
+"""Where the scSemiProfiler 5-fold (CV) and equal-budget results will appear, and a tolerant lookup for them.
+
+Shared helper of the 2026-09-30 paper-summary deck (not run directly). CPU only; reads files, never writes.
+
+Planned locations (2026-10-02; the GPU runs are prepared by another agent and may not exist yet):
+  CV           arm  scsemi__raw                 <PLAN>/scores/<ds>/scsemi_cv_20261002/{fold<k>,pooled}/
+  equal budget arms scsemi_n{5,10,20,40}__raw   <PLAN>/scores/<ds>/scsemi_budget_20261002/{fold<k>,pooled}/
+               (ImMicro and sepsis only)
+  extra metrics (classifier AUC, MMD^2, E_N, P/C at k = 3/5/10)
+               <PLAN>/scores_extra/<ds>/scsemi_cv_20261002/ and .../scsemi_budget_20261002/ (any depth below)
+  Giroux disease metrics without sex-linked genes, if rescored:
+               <PLAN>/scores_nosex/giroux2022/scsemi_cv_20261002/...
+
+The deck uses cross-fitted pooled calls only: directories below <exp>/ with a path part starting with "pooled"
+(pooled, pooled_deg, ...), never fold<k>/ or arms/. A call is accepted only if it scores the same donors with the
+same reference cells as the main pooled call and its generation receipt is not marked unverified (accept()).
+
+Every script that uses this module prints a note and draws nothing for scSemiProfiler when no accepted call exists.
+DECK_SCSEMI_PLAN_ROOT overrides <PLAN> for these lookups only (the synthetic presence test in a scratch copy).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+
+PLAN_DEFAULT = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/"
+                    "paired_finetune_intradataset_20260927")
+CV_EXP = "scsemi_cv_20261002"
+BUDGET_EXP = "scsemi_budget_20261002"
+CV_ARM = "scsemi__raw"
+BUDGET_RE = re.compile(r"^scsemi_n(\d+)__raw$")
+FOLD_RE = re.compile(r"^fold\d+$")
+LABEL_CV = "scSemiProfiler, 5-fold CV (other 4 folds)"
+
+
+def plan_root() -> Path:
+    return Path(os.environ.get("DECK_SCSEMI_PLAN_ROOT", str(PLAN_DEFAULT)))
+
+
+def is_test_root() -> bool:
+    return plan_root() != PLAN_DEFAULT
+
+
+def _pooled_dir(rel: Path) -> bool:
+    parts = rel.parts
+    return (not any(FOLD_RE.match(p) or p == "arms" for p in parts)) and any(p.startswith("pooled") for p in parts)
+
+
+def pooled_dirs(ds: str, exp: str, tree: str = "scores") -> list[Path]:
+    """Directories with a summary.json of the pooled calls of one experiment, 'pooled' before 'pooled_deg' etc."""
+    root = plan_root() / tree / ds / exp
+    if not root.is_dir():
+        return []
+    out = [sp.parent for sp in root.rglob("summary.json") if _pooled_dir(sp.parent.relative_to(root))]
+    return sorted(out, key=lambda p: (len(p.relative_to(root).parts), p.name != "pooled", str(p)))
+
+
+def _arms(d: Path) -> list[str]:
+    try:
+        return list(json.loads((d / "summary.json").read_text()).get("arms") or [])
+    except (OSError, ValueError):
+        return []
+
+
+def cv_calls(ds: str, tree: str = "scores") -> list[Path]:
+    """Pooled call directories that contain the CV arm."""
+    return [d for d in pooled_dirs(ds, CV_EXP, tree) if CV_ARM in _arms(d)]
+
+
+def budget_calls(ds: str, tree: str = "scores") -> dict[int, list[tuple[str, Path]]]:
+    """n -> [(arm, pooled call dir)] for the equal-budget arms scsemi_n<n>__raw."""
+    out: dict[int, list[tuple[str, Path]]] = {}
+    for d in pooled_dirs(ds, BUDGET_EXP, tree):
+        for a in _arms(d):
+            m = BUDGET_RE.match(a)
+            if m:
+                out.setdefault(int(m.group(1)), []).append((a, d))
+    return out
+
+
+def accept(summary: dict, ref_summary: dict, arm: str) -> list[str]:
+    """Reasons to reject one scSemiProfiler arm of a call against the main pooled call ([] = accepted)."""
+    why = []
+    if arm not in (summary.get("arms") or []):
+        why.append(f"arm {arm} not in the call")
+    if set(map(str, summary.get("donors", []))) != set(map(str, ref_summary.get("donors", []))):
+        why.append(f"donor set differs ({len(summary.get('donors', []))} vs {len(ref_summary.get('donors', []))})")
+    rs = summary.get("reference", {}).get("reference_sha256")
+    if rs != ref_summary.get("reference", {}).get("reference_sha256"):
+        why.append("reference cells differ (reference_sha256)")
+    if summary.get("per_arm", {}).get(arm, {}).get("receipt_verified", True) is False:
+        why.append("generation receipt not verified")
+    return why
+
+
+def extra_units(ds: str, exp: str) -> list[Path]:
+    """Extra-metric unit directories (metrics.csv + en.csv) below scores_extra/<ds>/<exp>/, pooled ones first;
+    fold<k>/ units are skipped (the deck shows the pooled design)."""
+    root = plan_root() / "scores_extra" / ds / exp
+    if not root.is_dir():
+        return []
+    out = []
+    for mp in root.rglob("metrics.csv"):
+        d = mp.parent
+        rel = d.relative_to(root)
+        if any(FOLD_RE.match(p) for p in rel.parts) or not (d / "en.csv").is_file():
+            continue
+        out.append(d)
+    return sorted(out, key=lambda p: (not any(x.startswith("pooled") for x in p.relative_to(root).parts),
+                                      len(p.relative_to(root).parts), str(p)))

paper-releases/pbisc-diffusion/updates/20261002T085943Z-deck-restructure-contrast-metrics-zeroshot-len/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sec01_overview.py

@@ -0,0 +1,633 @@
+"""Section 1 (model overview) figures for the 2026-09-30 paper-summary deck.
+
+Outputs (deck folder only):
+  figures/sec01_fig1a_denoiser.{svg,png,pdf}   deck redraw of manuscript Fig. 1a with slide-size labels
+  (temporary) sec01_fig1b_inference.{svg,png,pdf}  deck redraw of manuscript Fig. 1b, placed into sec01_slide_a
+  (not saved) sec01_corpus                     pretraining corpus panel, drawn inside sec01_slide_a
+  figures/sec01_slide_a.{png,pdf}              slide (a) composite, exactly 12.3 in wide
+  data/sec01_corpus_datasets.csv, data/sec01_recipe_k.csv, data/sec01_model_numbers.csv,
+  data/sec01_fig1_label_pt.csv (on-slide point size of every text line in the two redraws)
+
+The manuscript SVG is only read. The deck copies change label sizes, drop the panel letters and the
+legend row, widen a few boxes so the larger labels fit, and (panel b) say that cells differ by x_T and by
+the Bernoulli support draw (drawn read-out, manuscript Methods). CPU only; every number is read from the
+source files named below.
+"""
+import html
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+DECK = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/presentations/2026-09-30--paper-summary--r00")
+sys.path.insert(0, str(DECK / "tools"))
+import style  # noqa: E402
+
+import cairosvg  # 2.9.1, the renderer recorded in fig01_architecture.provenance.json  # noqa: E402
+import fitz  # PyMuPDF, only to check page sizes  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+import pandas as pd  # noqa: E402
+from PIL import ImageFont  # noqa: E402
+
+FIG = DECK / "figures"
+DATA = DECK / "data"
+
+MS = Path("/home/sj_server_1/PBISC/paper-release-20260928/manuscript")
+FIG1_SVG = MS / "figures/fig01_architecture.svg"
+METHODS = MS / "sections/methods.tex"
+SRC_MANIFEST = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_source/dataset_manifest.json")
+IDX_MANIFEST = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_7_no_annotation_sh_hwang/data/e2_full_index/dataset_manifest.json")
+M8 = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion")
+RUN = M8 / "runs/f01_6k_1x_seed20260627"
+CFG = RUN / "effective_config.json"
+STATUS = RUN / "RUN_STATUS.json"
+CONTRACT = RUN / "ALLCELL_DATA_CONTRACT.json"
+PLAN = M8 / "plans/full_recipe_allcells_6k_broad_20260909"
+TOPUP_CSV = PLAN / "topup_v1/topup_recipes.csv"
+SHARD_OFFSETS = PLAN / "topup_v1/shard_offsets.csv"
+COVERAGE = PLAN / "coverage_v1/summary.json"
+MODEL_PY = M8 / "src/pbisc_sdd/model.py"
+
+# Short readable labels for the 22 corpus datasets (text only; counts come from the manifest).
+LABELS = {
+    "001": "Perez SLE", "005": "OneK1K", "006": "AIDA", "007": "Miao RA", "009": "AIFI Health Atlas",
+    "010": "ScaleBio PBMC", "053": "Hao CITE-seq", "058": "COVID immunodeficiency",
+    "061": "RA at-risk (Savage)", "065": "Sound Life", "071": "JDM CITE-seq", "074": "COMBAT",
+    "081": "COVID atlas (Seq-Well)", "093": "SARS-CoV-2 local/systemic", "200": "Immunobiology of Aging",
+    "202": "Fatal COVID time course", "203": "Indonesia diversity", "204": "cHSPC aging / MDS",
+    "300b": "DRESS / DiHS", "301": "SLE B-cell study", "302": "SLE IL-36 stim", "304": "Parse 10M cytokine",
+}
+
+# On-slide sizes (inches). Slide (b): one keyword line under the diagram leaves about 5.25 in.
+A_HEIGHT_IN = 5.25
+SLIDE_A_H = 5.30          # composite height: leaves room for one keyword line in the 5.7-in content area
+W_FULL = style.FULL[0]    # 12.3 in
+
+# ============================================================== SVG copy with slide-size labels
+FONT_R = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 100)
+FONT_B = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 100)
+LS = 0.5  # letter-spacing set on the outer <g> of the figure
+SKEW = 0.2126
+
+
+def text_w(s, fs, bold=False):
+    s = html.unescape(s)
+    return (FONT_B if bold else FONT_R).getlength(s) * fs / 100.0 + LS * len(s)
+
+
+def attr(a, name):
+    m = re.search(rf'(?<![\w-]){name}="([^"]*)"', a)
+    return m.group(1) if m else None
+
+
+def set_attr(a, name, val):
+    new, n = re.subn(rf'(?<![\w-]){name}="[^"]*"', f'{name}="{val}"', a, count=1)
+    assert n == 1, (name, a)
+    return new
+
+
+def fmt(v):
+    return f"{v:.2f}".rstrip("0").rstrip(".")
+
+
+def map_d(d, fx, fy):
+    """Map absolute M/L/H/V/Z path data (one coordinate group per command, as in the manuscript SVG)."""
+    segs = []
+    for cmd, args in re.findall(r"([MLHVZ])([^MLHVZ]*)", d):
+        nums = [float(v) for v in re.findall(r"-?\d+(?:\.\d+)?", args)]
+        if cmd in "ML":
+            assert len(nums) == 2, d
+            segs.append(f"{cmd}{fmt(fx(nums[0]))},{fmt(fy(nums[1]))}")
+        elif cmd == "H":
+            assert len(nums) == 1, d
+            segs.append(f"H{fmt(fx(nums[0]))}")
+        elif cmd == "V":
+            assert len(nums) == 1, d
+            segs.append(f"V{fmt(fy(nums[0]))}")
+        else:
+            segs.append("Z")
+    return " ".join(segs)
+
+
+def d_xs(d):
+    toks = re.findall(r"[MLHVZ]|-?\d+(?:\.\d+)?", d)
+    xs, cmd, i = [], None, 0
+    while i < len(toks):
+        t = toks[i]
+        if t in "MLHVZ":
+            cmd = t
+            i += 1
+        elif cmd in "ML":
+            xs.append(float(t))
+            i += 2
+        elif cmd == "H":
+            xs.append(float(t))
+            i += 1
+        else:
+            i += 1
+    return xs
+
+
+def piecewise(knots):
+    xs = np.array([k[0] for k in knots], float)
+    ys = np.array([k[1] for k in knots], float)
+
+    def X(x):
+        if x <= xs[0]:
+            return x + (ys[0] - xs[0])
+        if x >= xs[-1]:
+            return x + (ys[-1] - xs[-1])
+        return float(np.interp(x, xs, ys))
+    return X
+
+
+# Panel a: widen the Expression column (+36) and the Conditioning column (+20); the main column only shifts.
+X_A = piecewise([(24, 24), (232, 268), (1184, 1220), (1416, 1472)])
+X_ID = piecewise([(0, 0), (1, 1)])
+
+TOKEN = re.compile(
+    r'<g transform="matrix\(1,0,-0\.2126,1,(?P<gtx>[-\d.]+),0\)">(?P<ginner>.*?)</g>'
+    r'|<text (?P<tattrs>[^>]*)>(?P<tbody>.*?)</text>'
+    r'|<path (?P<pattrs>[^>]*)/>')
+INNER_TEXT = re.compile(r'<text (?P<attrs>[^>]*)>(?P<body>.*?)</text>')
+INNER_PATH = re.compile(r'<path (?P<attrs>[^>]*)/>')
+
+
+def process_text_line(line, X, target=None, mode="c", dy=0.0, ax_fixed=None):
+    """Rescale one visual text line (several runs, skew groups, hat paths) about its anchor.
+    target: new main font size (None keeps it); mode 'c' centres on the old centre, 'l' keeps the left edge;
+    ax_fixed: old-coordinate centre to use instead of the measured one (re-centres a line in its box)."""
+    runs = []
+    for m in TOKEN.finditer(line):
+        if m.group("gtx") is not None:
+            t = INNER_TEXT.search(m.group("ginner"))
+            runs.append(dict(attrs=t.group("attrs"), body=t.group("body")))
+        elif m.group("tattrs") is not None:
+            runs.append(dict(attrs=m.group("tattrs"), body=m.group("tbody")))
+    for r in runs:
+        a = r["attrs"]
+        r.update(x=float(attr(a, "x")), y=float(attr(a, "y")), fs=float(attr(a, "font-size")),
+                 bold=attr(a, "font-weight") == "700", anchor=attr(a, "text-anchor") or "start")
+        r["w"] = text_w(r["body"], r["fs"], r["bold"])
+    fs0 = max(r["fs"] for r in runs)
+    yb = next(r["y"] for r in runs if r["fs"] == fs0)
+    if any(r["anchor"] in ("middle", "end") for r in runs):
+        assert len(runs) == 1, line
+        ax_old = runs[0]["x"]
+        extent = (runs[0]["x"] - runs[0]["w"] / 2, runs[0]["x"] + runs[0]["w"] / 2) if runs[0]["anchor"] == "middle" \
+            else (runs[0]["x"] - runs[0]["w"], runs[0]["x"])
+    else:
+        x0 = min(r["x"] for r in runs)
+        x1 = max(r["x"] + r["w"] for r in runs)
+        extent = (x0, x1)
+        ax_old = x0 if mode == "l" else (x0 + x1) / 2
+    f = (target / fs0) if target else 1.0
+    # the measured centre goes to the mapped box centre when one is given
+    ax_new = X(ax_fixed) if ax_fixed is not None else X(ax_old)
+    yb_new = yb + dy
+    fx = lambda x: ax_new + (x - ax_old) * f  # noqa: E731
+    fy = lambda y: yb_new + (y - yb) * f  # noqa: E731
+
+    def fix_text(a):
+        x, y, fs = float(attr(a, "x")), float(attr(a, "y")), float(attr(a, "font-size"))
+        a = set_attr(a, "x", fmt(fx(x)))
+        a = set_attr(a, "y", fmt(fy(y)))
+        return set_attr(a, "font-size", fmt(fs * f)), fy(y)
+
+    def fix_path(a):
+        return set_attr(a, "d", map_d(attr(a, "d"), fx, fy))
+
+    def repl(m):
+        if m.group("gtx") is not None:
+            inner = m.group("ginner")
+            t = INNER_TEXT.search(inner)
+            ta, ynew = fix_text(t.group("attrs"))
+            inner = inner.replace(t.group(0), f'<text {ta}>{t.group("body")}</text>')
+            inner = INNER_PATH.sub(lambda p: f'<path {fix_path(p.group("attrs"))}/>', inner)
+            return f'<g transform="matrix(1,0,-0.2126,1,{fmt(SKEW * ynew)},0)">{inner}</g>'
+        if m.group("tattrs") is not None:
+            ta, _ = fix_text(m.group("tattrs"))
+            return f'<text {ta}>{m.group("tbody")}</text>'
+        return f'<path {fix_path(m.group("pattrs"))}/>'
+
+    new = TOKEN.sub(repl, line)
+    w_new = (extent[1] - extent[0]) * f
+    info = dict(fs_old=fs0, fs_new=fs0 * f, width_new=w_new, center_new=fx((extent[0] + extent[1]) / 2),
+                text=" ".join(html.unescape(r["body"]) for r in runs))
+    return new, info
+
+
+def process_geometry_line(line, X):
+    def rect(m):
+        a = m.group(1)
+        x, w = float(attr(a, "x")), float(attr(a, "width"))
+        a = set_attr(a, "x", fmt(X(x)))
+        a = set_attr(a, "width", fmt(X(x + w) - X(x)))
+        return f"<rect {a}/>"
+
+    def circ(m):
+        a = m.group(1)
+        return f'<circle {set_attr(a, "cx", fmt(X(float(attr(a, "cx")))))}/>'
+
+    def path(m):
+        a = m.group(1)
+        d = attr(a, "d")
+        rigid = attr(a, "stroke") == "#FFFFFF" or d.count("M") > 1   # bar rulings and plus signs keep their size
+        if rigid:
+            xs = d_xs(d)
+            c = (min(xs) + max(xs)) / 2
+            dx = X(c) - c
+            return f'<path {set_attr(a, "d", map_d(d, lambda x: x + dx, lambda y: y))}/>'
+        return f'<path {set_attr(a, "d", map_d(d, X, lambda y: y))}/>'
+
+    line = re.sub(r"<rect ([^>]*)/>", rect, line)
+    line = re.sub(r"<circle ([^>]*)/>", circ, line)
+    line = re.sub(r"<path ([^>]*)/>", path, line)
+    return line
+
+
+def run_line(y, parts, fill, cx, fs=19.0):
+    """Build a centred text line from (text, style, space_before) parts at font fs.
+    style: 'n' upright, 'i' italic (skew group, as in the manuscript), 'sub' upright subscript at 0.7 fs."""
+    fsub = round(fs * 0.7, 2)
+    sp = text_w(" ", fs)
+    widths = [text_w(t, fsub if s == "sub" else fs) for t, s, _ in parts]
+    total = sum(widths) + sp * sum(1 for *_, g in parts if g)
+    x = cx - total / 2
+    out = []
+    for (t, s, gap), w in zip(parts, widths):
+        x += sp if gap else 0.0
+        size, yy = (fsub, y + round(fs * 0.17, 1)) if s == "sub" else (fs, y)
+        el = (f'<text x="{fmt(x)}" y="{fmt(yy)}" font-size="{fmt(size)}" font-weight="400" fill="{fill}" '
+              f'letter-spacing="0.5" text-anchor="start">{t}</text>')
+        if s == "i":
+            el = f'<g transform="matrix(1,0,-0.2126,1,{fmt(SKEW * yy)},0)">{el}</g>'
+        out.append(el)
+        x += w
+    return "".join(out), total
+
+
+# Line-specific geometry edits (1-based line numbers of the manuscript SVG); each old string must occur once.
+EDITS = {
+    126: [("M677.5,548 H657", "M677.5,548 H663")],
+    132: [('<rect x="577" y="511" width="80" height="73"', '<rect x="571" y="511" width="92" height="73"')],
+    135: [('<rect x="404" y="480" width="130" height="48"', '<rect x="398" y="480" width="142" height="48"')],
+    137: [('<rect x="404" y="551" width="130" height="48"', '<rect x="398" y="548" width="142" height="60"')],
+    140: [("M577,548 H560 V504 H542", "M571,548 H560 V504 H549")],
+    141: [("M560,548 V575 H542", "M560,548 V578 H549")],
+    142: [("M404,504 H366", "M398,504 H366")],
+    143: [("M404,575 H366 V539", "M398,578 H366 V539")],
+    190: [('<rect x="658" y="694" width="266" height="58"', '<rect x="658" y="694" width="266" height="64"')],
+    # panel b: wider reverse-sampling box for the longer last line
+    262: [("H782", "H772")], 264: [("H782", "H772")], 266: [("H782", "H772")],
+    270: [('<rect x="790" y="1000" width="276" height="164"', '<rect x="780" y="1000" width="296" height="164"')],
+    275: [("M1066,1082 H1098", "M1076,1082 H1098")],
+}
+# Text lines: (new main font size, anchor mode, baseline shift in SVG units)
+TEXT_A = {
+    31: (21, "c", 0), 32: (21, "c", 0), 33: (21, "c", 0), 37: (21, "c", 0), 38: (21, "c", 1),
+    42: (21, "c", -3), 44: (21, "c", -2),
+    43: (21, "c", -5, 128.0),   # manuscript line sits ~5 units right of its box centre (128); re-centred
+    59: (20, "c", 0), 60: (20, "c", 0),
+    61: (21, "l", 0), 75: (21, "c", 0), 76: (21, "c", 0), 77: (21, "l", 0), 83: (21, "c", 0),
+    89: (21, "c", 0), 130: (21, "c", 3), 133: (21, "c", -1), 134: (21, "c", 1), 138: (21, "c", -2),
+    139: (21, "c", 4), 158: (21, "c", 0), 159: (21, "c", 0), 160: (21, "l", 0), 162: (21, "l", 0),
+    176: (21, "c", 0), 177: (21, "c", 0), 178: (21, "l", 0), 182: (21, "l", 0), 191: (21, "c", -1),
+    192: (21, "c", 4), 195: (21, "c", -3), 198: (21, "c", 0), 199: (21, "c", 0), 208: (21, "c", 0),
+    214: (21, "c", 0), 217: (21, "c", 0), 221: (21, "c", 0), 222: (21, "c", 0),
+}
+TEXT_B = {
+    234: (19, "c", 0), 251: (19, "c", 0), 256: (19, "c", 0), 257: (19, "c", 0), 259: (19, "c", -2),
+    260: (19, "c", 2), 278: (19, "c", 0), 287: (19, "c", 0), 295: (19, "c", 0), 303: (19, "c", 0),
+    311: (19, "c", 0), 312: (19, "c", 0), 314: (19, "c", 0),
+}
+# panel a: lines 17-223 (drop the letter "a" 14-16 and the legend 224-229); panel b: 232-315 (drop letter "b")
+A_LINES = list(range(17, 224))
+B_LINES = [230] + list(range(232, 316))   # 230 opens the panel-b group, 315 closes it
+CROP_A = (18, 110, 1478, 777)     # after widening; boxes span y 116-771
+CROP_B = (18, 918, 1422, 1216)    # connector lines at y 926 and 1208
+
+
+def build_svg(lines, rng, X, text_cfg, crop, width_in, drop_bg=True):
+    head = lines[:12]  # xml decl .. defs .. outer <g>
+    x0, y0, x1, y1 = crop
+    vw, vh = x1 - x0, y1 - y0
+    h_in = width_in * vh / vw
+    head[1] = re.sub(r'width="[^"]*" height="[^"]*" viewBox="[^"]*"',
+                     f'width="{width_in:.4f}in" height="{h_in:.4f}in" viewBox="{x0} {y0} {vw} {vh}"', head[1])
+    body = [f'<rect x="{x0}" y="{y0}" width="{vw}" height="{vh}" fill="#FFFFFF" stroke="none"/>']
+    infos = []
+    for ln in rng:
+        s = lines[ln - 1]
+        for old, new in EDITS.get(ln, []):
+            assert s.count(old) == 1, (ln, old)
+            s = s.replace(old, new)
+        if ln == 274:   # panel b: cells differ by x_T and by the Bernoulli support draw (drawn read-out)
+            assert "the draw of" in s and 'font-size="18"' in s
+            s, w = run_line(1138.0, [("x", "i", False), ("T", "sub", False), ("and support draw differ", "n", True)],
+                            "#5C6C74", 928.0)
+            infos.append(dict(line=ln, fs_old=18.0, fs_new=19.0, width_new=w, center_new=928.0,
+                              text="x T and support draw differ (deck wording; manuscript: the draw of x T differs)"))
+        elif "<text" in s:
+            tgt, mode, dy, *fixed = text_cfg.get(ln, (None, "c", 0))
+            s, info = process_text_line(s, X, tgt, mode, dy, fixed[0] if fixed else None)
+            info["line"] = ln
+            infos.append(info)
+        elif X is not X_ID:
+            s = process_geometry_line(s, X)
+        body.append(s)
+    svg = "\n".join(head + body + ["</g></svg>"])
+    return svg, infos, h_in
+
+
+def render(svg, stem, width_in, outdir=None):
+    """outdir: where the svg/png/pdf go (default figures/). Intermediate panels that only feed a composite go to a
+    temporary folder (2026-10-02: figures/ holds only what a slide shows)."""
+    out = FIG if outdir is None else Path(outdir)
+    p_svg = out / f"{stem}.svg"
+    p_svg.write_text(svg)
+    cairosvg.svg2png(bytestring=svg.encode(), write_to=str(out / f"{stem}.png"), dpi=300)
+    cairosvg.svg2pdf(bytestring=svg.encode(), write_to=str(out / f"{stem}.pdf"), dpi=72)
+    doc = fitz.open(out / f"{stem}.pdf")
+    wpt = doc[0].rect.width
+    doc.close()
+    assert abs(wpt - width_in * 72) < 1.0, (stem, wpt, width_in * 72)
+    return out / f"{stem}.png"
+
+
+# ============================================================== corpus tables
+def fmt_cells(v):
+    if v >= 1e7:
+        return f"{v / 1e6:.1f}M"
+    if v >= 1e6:
+        return f"{v / 1e6:.2f}M"
+    return f"{v / 1e3:.0f}K"
+
+
+def corpus_tables():
+    src = json.loads(SRC_MANIFEST.read_text())
+    idx = json.loads(IDX_MANIFEST.read_text())
+    cov = json.loads(COVERAGE.read_text())
+    con = json.loads(CONTRACT.read_text())
+    base, over, raw, nsrc = (defaultdict(int) for _ in range(4))
+    for s in src["source_audit"]:
+        d = s["dataset_id"]
+        base[d] += int(s["base_rows"])
+        over[d] += int(s["overlay_rows"])
+        raw[d] += int(s["raw_rows"])
+        nsrc[d] += 1
+    ds = pd.DataFrame({"dataset_id": list(base)})
+    ds["base_rows"] = ds["dataset_id"].map(base)
+    ds["overlay_rows"] = ds["dataset_id"].map(over)
+    ds["cells"] = ds["base_rows"] + ds["overlay_rows"]
+    assert (ds["cells"] == ds["dataset_id"].map(raw)).all()
+    # cross-check against the index shards used by the run (base + overlay shards)
+    sh = pd.read_csv(SHARD_OFFSETS).groupby("dataset_id")["n_cells"].sum()
+    assert (ds.set_index("dataset_id")["cells"] == sh.reindex(ds["dataset_id"]).values).all()
+    ds["n_source_files"] = ds["dataset_id"].map(nsrc)
+    ds["label"] = ds["dataset_id"].str.split("_").str[0].map(LABELS)
+    assert ds["label"].notna().all()
+    ds = ds.sort_values("cells", ascending=False).reset_index(drop=True)
+    ds["rank"] = np.arange(1, len(ds) + 1)
+    ds["source"] = (f"{SRC_MANIFEST} :: source_audit[].base_rows + overlay_rows (= raw_rows) summed by dataset_id; "
+                    f"equals {SHARD_OFFSETS} n_cells by dataset_id")
+    total = int(ds["cells"].sum())
+    assert len(ds) == src["n_datasets"] == idx["n_datasets"] == 22
+    assert total == src["logical_cells"] == idx["n_cells"] == cov["source_cells_all_splits"]
+    assert int(ds["base_rows"].sum()) == src["base_cells"] and int(ds["overlay_rows"].sum()) == src["overlay_cells"]
+    ds[["rank", "label", "cells", "base_rows", "overlay_rows", "n_source_files", "dataset_id", "source"]].to_csv(
+        DATA / "sec01_corpus_datasets.csv", index=False)
+
+    kq = idx["k_quotas_per_epoch"]
+    kk = pd.DataFrame({"K": [f"{k:,}" for k in idx["k_values"]], "k_weight": idx["k_weights"],
+                       "recipes_per_epoch": [float(kq[str(k)]) for k in idx["k_values"]],
+                       "recipes_per_epoch_min": [int(kq[str(k)]) for k in idx["k_values"]],
+                       "recipes_per_epoch_max": [int(kq[str(k)]) for k in idx["k_values"]],
+                       "kind": "registered K grid"})
+    kk["source"] = f"{IDX_MANIFEST} :: k_values, k_weights, k_quotas_per_epoch"
+    assert int(kk["recipes_per_epoch"].sum()) == idx["train_recipes_per_epoch"]
+
+    pairing = con["pairing"]
+    cat = con["coverage_after_topup"]
+    reg = pairing["registered_recipes_per_epoch"]
+    per_ep = np.array(pairing["total_recipe_counts_by_epoch"]) - reg
+    slot = pd.DataFrame(cat["slot_coverage"])
+    assert (np.sort(per_ep) == np.sort(slot["topup_recipes"].values)).all()
+    assert int(per_ep.sum()) == cat["topup_recipes"]
+    tu = pd.read_csv(TOPUP_CSV)
+    assert len(tu) == cat["topup_recipes"] and tu["is_topup"].all() and (tu["split"] == "train").all()
+    topup = dict(n=int(len(tu)), k_min=int(tu["k"].min()), k_max=int(tu["k"].max()),
+                 k_median=float(tu["k"].median()), n_k_below_250=int((tu["k"] < 250).sum()),
+                 per_epoch_mean=float(per_ep.mean()), per_epoch_min=int(per_ep.min()), per_epoch_max=int(per_ep.max()),
+                 target_cells=int(cat["topup_target_cells"]), train_cells=int(cat["train_universe_cells"]),
+                 coverage=float(cat["train_cell_coverage_after_topup"]),
+                 recipes_by_epoch_min=int(min(pairing["total_recipe_counts_by_epoch"])),
+                 recipes_by_epoch_max=int(max(pairing["total_recipe_counts_by_epoch"])))
+    kk = pd.concat([kk, pd.DataFrame([{
+        "K": "top-up", "k_weight": np.nan, "recipes_per_epoch": topup["per_epoch_mean"],
+        "recipes_per_epoch_min": topup["per_epoch_min"], "recipes_per_epoch_max": topup["per_epoch_max"],
+        "kind": f"top-up, K {topup['k_min']}-{topup['k_max']:,} (mean over 16 epochs)",
+        "source": f"{CONTRACT} :: pairing.total_recipe_counts_by_epoch - registered_recipes_per_epoch; {TOPUP_CSV} :: k"}])],
+        ignore_index=True)
+    kk.to_csv(DATA / "sec01_recipe_k.csv", index=False)
+    meta = {"n_datasets": src["n_datasets"], "cells": total, "base_cells": src["base_cells"],
+            "overlay_cells": src["overlay_cells"], "train_recipes_per_epoch": idx["train_recipes_per_epoch"],
+            "train_recipe_pool_size": idx["train_recipe_pool_size"], "max_disjoint_epochs": idx["max_disjoint_epochs"],
+            "split_unit": idx["split_unit"], "split_fractions": idx["split_fractions"],
+            "corpus_fingerprint": idx["corpus_fingerprint"], "topup": topup,
+            "all_members_targets": cov["all_k_member_occurrences_become_targets"],
+            "original_target_exposures": con["coverage_after_topup"]["original_target_exposures"],
+            "observed_target_cells_by_epoch": con["observed_target_cells_by_epoch"]}
+    return ds, kk, meta
+
+
+def overlaps(fig, texts):
+    fig.canvas.draw()
+    r = fig.canvas.get_renderer()
+    bbs = [(t.get_text(), t.get_window_extent(r)) for t in texts if t.get_text()]
+    bad = []
+    for i in range(len(bbs)):
+        for j in range(i + 1, len(bbs)):
+            if bbs[i][1].overlaps(bbs[j][1]):
+                bad.append((bbs[i][0], bbs[j][0]))
+    return bad
+
+
+def draw_corpus(fig, W, H, y0, h, ds, kk, meta, fs=12):
+    """Corpus panels placed in inches: two sorted dataset columns on one shared log scale (values printed,
+    no axis), then recipes per epoch by K. y0 = bottom of the bar area, h = its height (inches)."""
+    half = int(np.ceil(len(ds) / 2))
+    parts = [ds.iloc[:half], ds.iloc[half:]]
+    lo, hi = 1e4, 3e7
+    cols = [(2.2, 2.35), (7.2, 2.35)]           # (left, width) in inches
+    texts = []
+    for (left, width), part in zip(cols, parts):
+        ax = fig.add_axes([left / W, y0 / H, width / W, h / H])
+        y = np.arange(len(part))
+        ax.barh(y, part["cells"], color=style.GREY, height=0.66)
+        for yi, v in zip(y, part["cells"]):
+            texts.append(ax.text(v * 1.2, yi, fmt_cells(v), va="center", ha="left", fontsize=fs, color=style.INK))
+        ax.set_xscale("log")
+        ax.set_xlim(lo, hi)
+        ax.set_ylim(half - 0.5, -0.5)
+        ax.set_yticks(y)
+        ax.set_yticklabels(part["label"], fontsize=fs)
+        texts += ax.get_yticklabels()
+        ax.tick_params(axis="y", length=0, pad=4)
+        ax.set_xticks([])
+        ax.minorticks_off()
+        for sp in ("left", "bottom"):
+            ax.spines[sp].set_visible(False)
+    t = meta["topup"]
+    texts.append(fig.text((cols[0][0] + cols[1][0] + cols[1][1]) / 2 / W, (y0 - 0.1) / H,
+                          f"cells per dataset (log scale) · {meta['n_datasets']} datasets · "
+                          f"{fmt_cells(meta['cells'])} cells · {fmt_cells(t['train_cells'])} in train split",
+                          ha="center", va="top", fontsize=fs + 1))
+
+    ax = fig.add_axes([10.75 / W, y0 / H, 0.95 / W, h / H])
+    y = np.arange(len(kk))
+    is_top = (kk["K"] == "top-up").values
+    ax.barh(y[~is_top], kk.loc[~is_top, "recipes_per_epoch"], color=style.INK, height=0.62)
+    ax.barh(y[is_top], kk.loc[is_top, "recipes_per_epoch"], color=style.GREY, height=0.62)
+    vmax = kk["recipes_per_epoch"].max()
+    for yi, v, top in zip(y, kk["recipes_per_epoch"], is_top):
+        lab = f"~{v:.0f}" if top else f"{v:,.0f}"
+        texts.append(ax.text(v + vmax * 0.05, yi, lab, va="center", ha="left", fontsize=fs))
+    ax.set_ylim(len(kk) - 0.5, -0.5)
+    ax.set_yticks(y)
+    ax.set_yticklabels(kk["K"], fontsize=fs)
+    texts += ax.get_yticklabels()
+    ax.tick_params(axis="y", length=0, pad=4)
+    ax.set_xlim(0, vmax * 1.02)
+    ax.set_xticks([])
+    for sp in ("left", "bottom"):
+        ax.spines[sp].set_visible(False)
+    ax.set_ylabel("K cells / recipe", fontsize=fs + 1, labelpad=6)
+    texts.append(ax.yaxis.label)
+    texts.append(fig.text((10.75 + 0.5) / W, (y0 - 0.1) / H, "recipes / epoch", ha="center", va="top", fontsize=fs + 1))
+    return texts
+
+
+def main():
+    FIG.mkdir(exist_ok=True)
+    DATA.mkdir(exist_ok=True)
+    lines = FIG1_SVG.read_text().split("\n")
+    assert len(lines) >= 316 and lines[230].startswith('<text x="24" y="914"') and 'y="813"' in lines[225]
+
+    # ---------- panel a (slide b) and panel b (slide a) deck copies
+    a_w = A_HEIGHT_IN * (CROP_A[2] - CROP_A[0]) / (CROP_A[3] - CROP_A[1])
+    svg_a, info_a, _ = build_svg(lines, A_LINES, X_A, TEXT_A, CROP_A, a_w)
+    render(svg_a, "sec01_fig1a_denoiser", a_w)
+    svg_b, info_b, b_h = build_svg(lines, B_LINES, X_ID, TEXT_B, CROP_B, W_FULL)
+    import tempfile
+    tmp = Path(tempfile.mkdtemp(prefix="sec01_"))   # panel b only feeds the slide (a) composite
+    b_png = render(svg_b, "sec01_fig1b_inference", W_FULL, outdir=tmp)
+
+    # on-slide point size of every text line
+    pt_a = A_HEIGHT_IN * 72 / (CROP_A[3] - CROP_A[1])
+    pt_b = W_FULL * 72 / (CROP_B[2] - CROP_B[0])
+    rows = [dict(panel="a (slide b)", placed_in=f"{a_w:.2f} x {A_HEIGHT_IN:.2f}", pt_per_unit=pt_a, **i) for i in info_a]
+    rows += [dict(panel="b (slide a)", placed_in=f"{W_FULL:.2f} x {b_h:.3f}", pt_per_unit=pt_b, **i) for i in info_b]
+    lab = pd.DataFrame(rows)
+    lab["pt_on_slide"] = lab["fs_new"] * lab["pt_per_unit"]
+    lab = lab[["panel", "line", "text", "fs_old", "fs_new", "pt_on_slide", "width_new", "center_new", "placed_in", "pt_per_unit"]]
+    lab.to_csv(DATA / "sec01_fig1_label_pt.csv", index=False)
+
+    # ---------- corpus
+    ds, kk, meta = corpus_tables()
+    W = W_FULL
+    fig = plt.figure(figsize=(W, 2.75))
+    texts = draw_corpus(fig, W, 2.75, 0.45, 2.2, ds, kk, meta)
+    bad = overlaps(fig, texts)
+    assert not bad, bad
+    plt.close(fig)   # standalone corpus panel: layout check only; the slide shows it inside sec01_slide_a
+
+    # ---------- slide (a) composite: exactly 12.3 x 5.3 in, panel b redraw on top
+    H = SLIDE_A_H
+    img = plt.imread(b_png)
+    fig = plt.figure(figsize=(W, H))
+    ax_img = fig.add_axes([0, 1 - b_h / H, 1, b_h / H])
+    ax_img.imshow(img, interpolation="lanczos")
+    ax_img.set_axis_off()
+    y0 = 0.45
+    texts = draw_corpus(fig, W, H, y0, H - b_h - 0.16 - y0, ds, kk, meta)
+    bad = overlaps(fig, texts)
+    assert not bad, bad
+    r = fig.canvas.get_renderer()
+    for t in texts:   # every corpus label stays on the canvas
+        bb = t.get_window_extent(r)
+        assert bb.x0 >= 0 and bb.x1 <= W * fig.dpi and bb.y0 >= 0, t.get_text()
+    with plt.rc_context({"savefig.bbox": "standard"}):   # keep the canvas at exactly 12.3 x 5.3 in
+        for ext in ("png", "pdf"):
+            fig.savefig(FIG / f"sec01_slide_a.{ext}", dpi=300)
+    plt.close(fig)
+
+    # ---------- numbers used on the slides, with sources
+    cfg = json.loads(CFG.read_text())
+    st = json.loads(STATUS.read_text())
+    idx = json.loads(IDX_MANIFEST.read_text())
+    con = json.loads(CONTRACT.read_text())
+    hd = cfg["model"]["hidden_dims"]
+    blocks = hd + hd[-2::-1]
+    assert "descending half of the symmetric MLP" in MODEL_PY.read_text()
+    meth = METHODS.read_text().split("\n")
+    assert "Generation used EMA weights and 50 deterministic DDIM steps ($\\eta=0$)" in meth[57]
+    assert "The drawn read-out is implemented in the standalone sampler that generated every set scored in this paper" in meth[98]
+    t = meta["topup"]
+    nums = [
+        ("n_datasets", meta["n_datasets"], f"{SRC_MANIFEST} :: n_datasets (= {IDX_MANIFEST} :: n_datasets)"),
+        ("corpus_cells", meta["cells"], f"{SRC_MANIFEST} :: logical_cells = base_cells + overlay_cells (= {IDX_MANIFEST} :: n_cells; = {COVERAGE} :: source_cells_all_splits)"),
+        ("corpus_base_cells", meta["base_cells"], f"{SRC_MANIFEST} :: base_cells"),
+        ("corpus_overlay_cells", meta["overlay_cells"], f"{SRC_MANIFEST} :: overlay_cells"),
+        ("train_split_cells", t["train_cells"], f"{CONTRACT} :: coverage_after_topup.train_universe_cells"),
+        ("split", f"{idx['split_unit']} {idx['split_fractions']}", f"{IDX_MANIFEST} :: split_unit, split_fractions"),
+        ("k_values", " ".join(str(k) for k in idx["k_values"]), f"{IDX_MANIFEST} :: k_values"),
+        ("registered_recipes_per_epoch", idx["train_recipes_per_epoch"], f"{IDX_MANIFEST} :: train_recipes_per_epoch"),
+        ("train_recipe_pool_size", idx["train_recipe_pool_size"], f"{IDX_MANIFEST} :: train_recipe_pool_size"),
+        ("max_disjoint_epochs", idx["max_disjoint_epochs"], f"{IDX_MANIFEST} :: max_disjoint_epochs (schedule_slots)"),
+        ("topup_recipes_total", t["n"], f"{CONTRACT} :: coverage_after_topup.topup_recipes (= rows of {TOPUP_CSV})"),
+        ("topup_recipes_per_epoch_mean_min_max", f"{t['per_epoch_mean']:.1f} {t['per_epoch_min']} {t['per_epoch_max']}", f"{CONTRACT} :: pairing.total_recipe_counts_by_epoch - pairing.registered_recipes_per_epoch"),
+        ("recipes_per_epoch_actual_min_max", f"{t['recipes_by_epoch_min']} {t['recipes_by_epoch_max']}", f"{CONTRACT} :: pairing.total_recipe_counts_by_epoch"),
+        ("topup_k_min_median_max", f"{t['k_min']} {t['k_median']:.0f} {t['k_max']}", f"{TOPUP_CSV} :: k"),
+        ("topup_recipes_k_below_250", t["n_k_below_250"], f"{TOPUP_CSV} :: k < 250"),
+        ("train_cell_coverage_after_topup", t["coverage"], f"{CONTRACT} :: coverage_after_topup.train_cell_coverage_after_topup"),
+        ("all_member_cells_are_targets", meta["all_members_targets"], f"{COVERAGE} :: all_k_member_occurrences_become_targets"),
+        ("target_cells_per_epoch_min_max", f"{min(meta['observed_target_cells_by_epoch'])} {max(meta['observed_target_cells_by_epoch'])}", f"{CONTRACT} :: observed_target_cells_by_epoch"),
+        ("corpus_fingerprint_matches_run", idx["corpus_fingerprint"] == st["corpus_fingerprint"] == con["pairing"]["source_corpus_fingerprint"],
+         f"{IDX_MANIFEST} :: corpus_fingerprint vs {STATUS} :: corpus_fingerprint and {CONTRACT} :: pairing.source_corpus_fingerprint"),
+        ("n_genes", cfg["data"]["n_genes"], f"{CFG} :: data.n_genes (= {STATUS} :: n_genes)"),
+        ("condition_dim", st["condition_dim"], f"{STATUS} :: condition_dim (= 3G+6)"),
+        ("parameters", st["parameters"], f"{STATUS} :: parameters"),
+        ("hidden_dims_descending_half", "-".join(map(str, hd)), f"{CFG} :: model.hidden_dims ({MODEL_PY} SparseDenoiserConfig: descending half of a symmetric skip MLP)"),
+        ("denoiser_blocks", f"{len(blocks)} blocks: {'-'.join(map(str, blocks))}", f"derived: hidden_dims + reversed(hidden_dims[:-1]); matches Fig. 1a '7 blocks + skip sums'"),
+        ("context_dim", cfg["model"]["context_dim"], f"{CFG} :: model.context_dim"),
+        ("time_embedding_dim", cfg["model"]["time_embedding_dim"], f"{CFG} :: model.time_embedding_dim"),
+        ("sampler", "EMA weights, 50 DDIM steps, eta 0", f"{METHODS} l.58"),
+        ("support_readout", "drawn (Bernoulli): keep gene g if u < sigmoid(logit); used for every scored set", f"{METHODS} l.99 (Support read-out)"),
+        ("ema_decay", cfg["training"]["ema_decay"], f"{CFG} :: training.ema_decay"),
+        ("epochs_completed", st["epochs_completed"], f"{STATUS} :: epochs_completed (= 16 disjoint schedule slots; {IDX_MANIFEST} :: schedule_slots)"),
+        ("status", st["status"], f"{STATUS} :: status"),
+    ]
+    assert cfg["data"]["n_genes"] == st["n_genes"]
+    assert st["condition_dim"] == 3 * st["n_genes"] + 6
+    assert st["epochs_completed"] == idx["schedule_slots"] == idx["max_disjoint_epochs"] == 16
+    assert idx["train_recipes_per_epoch"] * idx["schedule_slots"] == idx["train_recipe_pool_size"]
+    assert meta["original_target_exposures"] == sum(int(k) * int(v) for k, v in zip(
+        idx["k_values"], [idx["k_quotas_per_epoch"][str(k)] for k in idx["k_values"]])) * idx["schedule_slots"]
+    pd.DataFrame(nums, columns=["key", "value", "source"]).to_csv(DATA / "sec01_model_numbers.csv", index=False)
+
+    print(f"panel a placed {a_w:.2f} x {A_HEIGHT_IN} in, {pt_a:.4f} pt/unit; panel b {W_FULL} x {b_h:.3f} in, {pt_b:.4f} pt/unit")
+    for p, g in lab.groupby("panel"):
+        g = g.sort_values("pt_on_slide")
+        print(p, "min label pt", round(g["pt_on_slide"].min(), 2), "|", g.iloc[0]["text"][:40])
+    print("datasets", meta["n_datasets"], "cells", meta["cells"], fmt_cells(meta["cells"]))
+    print(ds[["label", "cells"]].to_string(index=False))
+    print(kk[["K", "recipes_per_epoch", "recipes_per_epoch_min", "recipes_per_epoch_max"]].to_string(index=False))
+    for k, v, _ in nums:
+        print(k, v)
+
+
+if __name__ == "__main__":
+    main()