Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261008T121550Z-deck-fig4-rules-no-broadcast/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/secS_deconvolution.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Fig. 4 (since 2026-10-08): cell-type deconvolution given the same paired donors vs LoRA (2026-10-07). User
+decisions of 2026-10-08: the comparison moves to Fig. 4, explicitly labelled as cell-type deconvolution; no
+bulk-broadcast baseline; the 5-donor draws are the main comparison.
+
+Source: plans/bayesprism_paired_20261006/results/ (tools/score_bp.py, aggregate_bp.py): BayesPrism with its recommended
+gene set (gene mode "full") and official CIBERSORTx (Docker, S-mode Fractions; HiRes when it ran) on the paired
+benchmark's own splits, donors, observed truth and scorer; the reference is the split's paired donors' observed cells
+(5-donor draws: the draw's 5 training donors; 5-fold CV: each fold's LoRA training + inner-validation pairs).
+Two slides:
+  "Cell-type deconvolution, same pairs: composition"    composition L1, 5-donor draws (mean +- SD) and pooled 5-fold CV
+  "Cell-type deconvolution, same pairs: disease signal" per-type case-vs-control logFC r, partial r beyond the bulk,
+                                                       top-50 DEG overlap (5-donor draws, the four disease cohorts)
+Outputs: figures/secS_deconv_{composition,disease}.{png,pdf}, data/secS_deconvolution.csv,
+data/secS_deconvolution_slide_text.json.  CPU only, plotting only.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+TOOLS = Path(__file__).resolve().parent
+sys.path.insert(0, str(TOOLS))
+import style as ST  # noqa: E402
+from grouped_bars import grouped_bars  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+
+DECK = TOOLS.parent
+FIGDIR, OUTDATA = DECK / "figures", DECK / "data"
+RES = Path("/home/sj_server_1/PBISC/immun-pbmc-fm/model_8_sparse_data_diffusion/plans/bayesprism_paired_20261006/results")
+ORDER = ["immicro", "ye2026_sepsis", "ji2025_chili", "imperial_eskd", "giroux2022"]
+NAME = {"immicro": "ImMicro", "ye2026_sepsis": "Sepsis", "ji2025_chili": "Ji ChILI", "imperial_eskd": "Imperial",
+        "giroux2022": "Giroux"}
+COL = {"lora": ST.ARM["lora"], "bp": "#009E73", "cx": "#CC79A7", "scsemi": ST.ARM["scsemi"]}
+
+
+def load(mode: str, kind: str) -> pd.DataFrame:
+    f = RES / f"TABLE_{kind}{'' if mode == 'score' else '_' + mode}.csv"
+    return pd.read_csv(f) if f.exists() else pd.DataFrame()
+
+
+def main() -> int:
+    bp_f, bp_c = load("full", "fewshot"), load("full", "cv")
+    cx_f, cx_c = load("cibersortx", "fewshot"), load("cibersortx", "cv")
+    if bp_f.empty:
+        raise SystemExit("no BayesPrism results")
+    for t in (bp_f, cx_f):
+        if not t.empty:
+            t["best_l1"] = t[["bp_l1_final", "bp_l1_first"]].min(1)
+    for t in (bp_c, cx_c):
+        if not t.empty:
+            t["best_l1"] = t[["bp_l1_final", "bp_l1_first"]].min(1)
+    have_cx = not cx_f.empty
+    have_cx_z = have_cx and cx_f["bp_r"].notna().any()
+    rows = []
+
+    def agg(t, ds, col):
+        g = t[t.cohort == ds][col] if not t.empty else pd.Series(dtype=float)
+        g = g.dropna()
+        return (float(g.mean()), float(g.std(ddof=1)) if len(g) > 1 else np.nan, int(len(g)))
+
+    # ---------------------------------------------------------------- slide 1: composition
+    fig, axes = plt.subplots(1, 2, figsize=ST.FULL, sharey=True)
+    arms = [("lora", "PBISC LoRA", COL["lora"], None), ("bp", "BayesPrism", COL["bp"], None)]
+    if have_cx:
+        arms.append(("cx", "CIBERSORTx", COL["cx"], None))
+    vals = {}
+    for ds in ORDER:
+        vals[("f", ds, "lora")] = agg(bp_f, ds, "lora_l1")
+        vals[("f", ds, "bp")] = agg(bp_f, ds, "best_l1")
+        vals[("f", ds, "cx")] = agg(cx_f, ds, "best_l1") if have_cx else (np.nan, np.nan, 0)
+        vals[("c", ds, "lora")] = agg(bp_c, ds, "lora_l1")
+        vals[("c", ds, "bp")] = agg(bp_c, ds, "best_l1")
+        vals[("c", ds, "cx")] = agg(cx_c, ds, "best_l1") if not cx_c.empty else (np.nan, np.nan, 0)
+        vals[("c", ds, "scsemi")] = agg(bp_c, ds, "scsemi_l1") if "scsemi_l1" in bp_c else (np.nan, np.nan, 0)
+    for pi, (key, ax, title) in enumerate((("f", axes[0], "5 donors (mean of 5 draws)"),
+                                          ("c", axes[1], "5-fold CV, pooled"))):
+        arms_p = arms + ([("scsemi", "scSemiProfiler", COL["scsemi"], None)] if key == "c" else [])
+        grouped_bars(ax, [NAME[d] for d in ORDER], [a for a in arms_p],
+                     lambda i, a: vals[(key, ORDER[i], a)][0], ST.FS, fmt=None if key == "f" else (lambda v: f"{v:.2f}"))
+        if key == "f":   # error bars = SD over draws; value labels above the caps
+            for k_, (a, _l, c, _h) in enumerate(arms_p):
+                xs = np.arange(len(ORDER)) + (k_ - (len(arms_p) - 1) / 2) * (0.8 / len(arms_p))
+                ys = np.asarray([vals[(key, d, a)][0] for d in ORDER])
+                es = np.nan_to_num(np.asarray([vals[(key, d, a)][1] for d in ORDER]))
+                ax.errorbar(xs, ys, yerr=es, fmt="none", ecolor=ST.SUBINK, elinewidth=1, capsize=2, zorder=3)
+                for x_, y_, e_ in zip(xs, ys, es):
+                    if np.isfinite(y_):
+                        ax.text(x_, y_ + e_ + 0.015, f"{y_:.2f}", ha="center", va="bottom", fontsize=ST.FS - 6,
+                                color=ST.SUBINK)
+        ax.set_title(title, fontsize=ST.FS - 1, loc="left")
+        if pi == 0:
+            ax.set_ylabel("Composition L1 (lower is better)")
+    handles = [plt.Rectangle((0, 0), 1, 1, color=c) for _a, _l, c, _h in arms + [("scsemi", "", COL["scsemi"], None)]]
+    labels = [l for _a, l, _c, _h in arms] + ["scSemiProfiler"]
+    axes[1].legend(handles, labels, loc="upper left", fontsize=ST.FS - 3)
+    fig.tight_layout()
+    ST.save(fig, "secS_deconv_composition", FIGDIR)
+    # ---------------------------------------------------------------- slide 2: disease signal (5-donor draws)
+    dis = [d for d in ORDER if d != "immicro"]
+    fig, axes = plt.subplots(1, 3, figsize=ST.FULL)
+    arms2 = [("lora", "PBISC LoRA", COL["lora"], None), ("bp", "BayesPrism Z", COL["bp"], None)]
+    if have_cx_z:
+        arms2.append(("cx", "CIBERSORTx HiRes", COL["cx"], None))
+    for ax, (metric, lab) in zip(axes, (("r", "Cell-type logFC r"), ("partial", "Partial r beyond bulk"),
+                                        ("deg", "Top-50 DEG overlap"))):
+        a2 = arms2   # no bulk-broadcast baseline (user decision 2026-10-08)
+
+        def val(i, a, metric=metric):
+            ds = dis[i]
+            t = cx_f if a == "cx" else bp_f
+            col = {"r": "lora_r", "partial": "lora_partial", "deg": "lora_deg"}[metric] if a == "lora" else \
+                {"r": "bp_r", "partial": "bp_partial", "deg": "bp_deg"}[metric]
+            return agg(t, ds, col)[0]
+        grouped_bars(ax, [NAME[d] for d in dis], a2, val, ST.FS - 1,
+                     fmt=(lambda v: f"{v:.0f}") if metric == "deg" else (lambda v: f"{v:.2f}"))
+        ax.set_title(lab, fontsize=ST.FS - 1, loc="left", fontweight="bold" if metric == "partial" else "normal")
+        ax.tick_params(axis="x", labelsize=ST.FS - 4)
+    handles = [plt.Rectangle((0, 0), 1, 1, color=c) for _a, _l, c, _h in arms2]
+    axes[0].legend(handles, [l for _a, l, _c, _h in arms2], loc="upper left", fontsize=ST.FS - 4)
+    fig.tight_layout()
+    ST.save(fig, "secS_deconv_disease", FIGDIR)
+    # ---------------------------------------------------------------- numbers, keywords
+    for ds in ORDER:
+        r = {"cohort": NAME[ds]}
+        for key in ("f", "c"):
+            for a in ("lora", "bp", "cx", "scsemi"):
+                if (key, ds, a) in vals:
+                    r[f"{key}_{a}_l1"] = vals[(key, ds, a)][0]
+        for a, t, cols in (("lora", bp_f, ("lora_r", "lora_partial", "lora_deg")), ("bp", bp_f, ("bp_r", "bp_partial", "bp_deg")),
+                           ("cx", cx_f, ("bp_r", "bp_partial", "bp_deg"))):
+            for m, c in zip(("r", "partial", "deg"), cols):
+                r[f"f_{a}_{m}"] = agg(t, ds, c)[0] if (c and not t.empty) else np.nan
+        rows.append(r)
+    tab = pd.DataFrame(rows)
+    tab.to_csv(OUTDATA / "secS_deconvolution.csv", index=False)
+    def wins(t):
+        """draw counts where LoRA-5 beats the method (rows with both values only)"""
+        m = t.bp_r.notna() & t.lora_r.notna()
+        return {"l1": (int((t.lora_l1 < t.best_l1).sum()), len(t)),
+                "r": (int((t.lora_r > t.bp_r)[m].sum()), int(m.sum())),
+                "partial": (int((t.lora_partial > t.bp_partial)[m].sum()), int(m.sum())),
+                "deg": (int((t.lora_deg > t.bp_deg)[m].sum()), int((t.lora_deg < t.bp_deg)[m].sum()),
+                        int((t.lora_deg == t.bp_deg)[m].sum()), int(m.sum()))}
+    wb = wins(bp_f)
+    wc = wins(cx_f) if have_cx_z else None
+    # 5-fold: cohorts where PBISC has the lowest composition L1 of every method shown
+    best_cv = []
+    for ds in ORDER:
+        others = [vals[("c", ds, a)][0] for a in ("bp", "cx", "scsemi")]
+        others = [x for x in others if np.isfinite(x)]
+        best_cv.append(bool(others) and vals[("c", ds, "lora")][0] < min(others))
+    beaten_by = [NAME[d] + " (scSemiProfiler)" for d, b in zip(ORDER, best_cv) if not b]
+    # CIBERSORTx draws without any HiRes-imputed gene in the contrast types (no cell-type logFC)
+    cx_noz = ({NAME[d]: int(cx_f[(cx_f.cohort == d)].bp_r.isna().sum()) for d in dis} if have_cx_z else {})
+    cx_noz = {k: v for k, v in cx_noz.items() if v}
+    if have_cx:
+        kw1 = [f"PBISC closer than BayesPrism in {wb['l1'][0]}/{wb['l1'][1]} draws, "
+               f"than CIBERSORTx in {wins(cx_f)['l1'][0]}/{wins(cx_f)['l1'][1]}",
+               "Deconvolution misreads real bulk",
+               f"5-fold: PBISC lowest in {sum(best_cv)} of {len(ORDER)} cohorts"]
+    else:
+        kw1 = [f"PBISC closer in {wb['l1'][0]} of {wb['l1'][1]} draws", "Deconvolution misreads real bulk",
+               f"5-fold: PBISC lowest in {sum(best_cv)} of {len(ORDER)} cohorts"]
+    if wc:
+        kw2 = [f"logFC r: PBISC ahead in {wb['r'][0]}/{wb['r'][1]} draws (BayesPrism), {wc['r'][0]}/{wc['r'][1]} "
+               "(CIBERSORTx)",
+               f"Beyond bulk: PBISC ahead in {wb['partial'][0]}/{wb['partial'][1]} and {wc['partial'][0]}/{wc['partial'][1]}",
+               f"Top-50 DEG mixed: PBISC ahead in {wb['deg'][0]}/{wb['deg'][3]} and {wc['deg'][0]}/{wc['deg'][3]}"]
+    else:
+        kw2 = [f"logFC r: PBISC ahead in {wb['r'][0]}/{wb['r'][1]} draws", f"Beyond bulk: PBISC {wb['partial'][0]}/{wb['partial'][1]}",
+               f"Top-50 DEG mixed: {wb['deg'][0]} vs {wb['deg'][1]}"]
+    num1 = [{"value": "; ".join(f"{NAME[d]}: 5 donors L1 PBISC {vals[('f', d, 'lora')][0]:.3f} / BayesPrism "
+                                f"{vals[('f', d, 'bp')][0]:.3f}" + (f" / CIBERSORTx {vals[('f', d, 'cx')][0]:.3f}" if have_cx else "")
+                                + f"; 5-fold PBISC {vals[('c', d, 'lora')][0]:.3f} / BayesPrism {vals[('c', d, 'bp')][0]:.3f}"
+                                + (f" / CIBERSORTx {vals[('c', d, 'cx')][0]:.3f}" if np.isfinite(vals[('c', d, 'cx')][0]) else "")
+                                + (f" / scSemiProfiler {vals[('c', d, 'scsemi')][0]:.3f}" if np.isfinite(vals[('c', d, 'scsemi')][0])
+                                   else " / scSemiProfiler running")
+                                for d in ORDER), "source": "data/secS_deconvolution.csv"}]
+    ti = tab.set_index("cohort")
+    num2 = [{"value": "; ".join(f"{NAME[d]}: logFC r PBISC {ti.loc[NAME[d], 'f_lora_r']:.3f} / BayesPrism "
+                                f"{ti.loc[NAME[d], 'f_bp_r']:.3f} / CIBERSORTx {ti.loc[NAME[d], 'f_cx_r']:.3f}; "
+                                f"partial r {ti.loc[NAME[d], 'f_lora_partial']:.3f} / "
+                                f"{ti.loc[NAME[d], 'f_bp_partial']:.3f} / {ti.loc[NAME[d], 'f_cx_partial']:.3f}; DEG "
+                                f"{ti.loc[NAME[d], 'f_lora_deg']:.1f} / {ti.loc[NAME[d], 'f_bp_deg']:.1f} / "
+                                f"{ti.loc[NAME[d], 'f_cx_deg']:.1f}" for d in dis),
+             "source": "data/secS_deconvolution.csv"},
+            {"value": f"draws where PBISC LoRA-5 beats BayesPrism: logFC r {wb['r'][0]}/{wb['r'][1]}, partial r "
+                      f"{wb['partial'][0]}/{wb['partial'][1]}, top-50 DEG {wb['deg'][0]} (BayesPrism ahead "
+                      f"{wb['deg'][1]}, ties {wb['deg'][2]})" + (
+                      f"; beats CIBERSORTx: logFC r {wc['r'][0]}/{wc['r'][1]}, partial r {wc['partial'][0]}/"
+                      f"{wc['partial'][1]}, top-50 DEG {wc['deg'][0]} (CIBERSORTx ahead {wc['deg'][1]}, ties "
+                      f"{wc['deg'][2]})" if wc else ""),
+             "source": "plans/bayesprism_paired_20261006/results/TABLE_fewshot_full.csv, TABLE_fewshot_cibersortx.csv"}]
+    cx_note = ("CIBERSORTx: official Docker images (x86, run under qemu emulation on server_1), single-cell "
+               "reference mode with S-mode batch correction (up to 400 reference cells per type), fractions in cell "
+               "units (divided by each type's mean UMI per reference cell). " if have_cx else
+               "CIBERSORTx: not yet available. ")
+    cx_note += ("CIBERSORTx HiRes gives per-sample cell-type expression for the genes it imputes per type (others "
+                "are written as 1 and count as zero here)"
+                + (("; it imputed no gene of the four contrast types in "
+                    + " and ".join(f"{v} {k}" for k, v in cx_noz.items())
+                    + f" draw{'s' if sum(cx_noz.values()) > 1 else ''}, which therefore have no CIBERSORTx disease "
+                      "score") if cx_noz else "") + ". "
+                if have_cx_z else
+                "CIBERSORTx HiRes (cell-type expression) did not run on these inputs, so the disease slide shows "
+                "BayesPrism only. ")
+    full1 = ("Cell-type deconvolution (cell-type fractions and per-type expression, not single cells) given the same "
+             "paired donors as PBISC LoRA, on the paired benchmark's own "
+             "splits, observed truth and scorer: 5-donor draws (reference = the draw's 5 training donors' observed "
+             "cells, mixture = the test samples' real bulk) and 5-fold CV (reference = each fold's LoRA training + "
+             "inner-validation pairs; pooled). BayesPrism: recommended gene set (protein-coding minus chrX/Y/M and "
+             "ribosomal genes, 15-19k), reference states = gate | AIFI L2; its better theta (initial or final) in cell "
+             "units is shown. " + cx_note + "Composition L1 over the six-type gate, lower is better. 5-fold: "
+             + (f"PBISC has the lowest L1 except in {', '.join(beaten_by)}" if beaten_by else
+                "PBISC has the lowest L1 in every cohort")
+             + ("; scSemiProfiler bars appear as its 5-fold runs finish ('n/a' = still running)"
+                if any(not np.isfinite(vals[("c", d, "scsemi")][0]) for d in ORDER) else "")
+             + ". Pipeline check: "
+             "on pseudobulk mixtures BayesPrism recovers the observed mRNA shares (e.g. T 0.39 vs 0.38), so the error "
+             "comes from real bulk. Source: plans/bayesprism_paired_20261006/results/RESULTS_full.md, "
+             "RESULTS_cibersortx.md.")
+    full2 = ("Cell-type deconvolution, not single cells. Case-vs-control per-cell-type logFC (mean CP10K; T, B, "
+             "Monocyte, NK) from BayesPrism's posterior cell-type expression Z and CIBERSORTx HiRes, scored with the "
+             "benchmark's own functions; partial r = the same r after both logFCs are residualised on the input bulk's "
+             "logFC (the cell-type signal the bulk does not carry); top-50 DEG = Welch, summed over types (many ties at "
+             "0 in Ji and Giroux). 5-donor draws (the 5-pair comparison), mean "
+             "over draws with a score. Giroux excludes sex-linked genes, as everywhere in the deck. " + cx_note
+             + "Source: plans/bayesprism_paired_20261006/results/RESULTS_full.md, RESULTS_cibersortx.md.")
+    slides = [
+        {"title": "Cell-type deconvolution, same pairs: composition", "layout": "full",
+         "figures": [str(FIGDIR / "secS_deconv_composition.png")], "keywords": kw1,
+         "footnote_short": "Same donors, truth and scorer as PBISC. Reference = the paired donors' cells.",
+         "footnote": full1, "numbers": num1},
+        {"title": "Cell-type deconvolution, same pairs: disease signal", "layout": "full",
+         "figures": [str(FIGDIR / "secS_deconv_disease.png")], "keywords": kw2,
+         "footnote_short": "5-donor draws, mean over draws. Partial r = cell-type signal beyond the bulk.",
+         "footnote": full2, "numbers": num2}]
+    for s in slides:
+        if len(s["footnote_short"]) > 110:
+            raise SystemExit("short footnote too long")
+    out = {"section": "S-deconvolution", "scripts": [str(Path(__file__).resolve())],
+           "generated_from": "tools/secS_deconvolution.py (rerun to refresh; do not edit by hand)", "slides": slides}
+    (OUTDATA / "secS_deconvolution_slide_text.json").write_text(json.dumps(out, indent=1, ensure_ascii=False))
+    print("\n".join(kw1 + kw2))
+    print(tab.round(3).to_string(index=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

paper-releases/pbisc-diffusion/updates/20261008T121550Z-deck-fig4-rules-no-broadcast/diffusion/dataset/server_1/model8/presentations/2026-09-30--paper-summary--r00/tools/sync_sec09_text.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Copy generated slide text into data/slides_spec.json.
+
+sec09_paired_validation.py regenerates titles, keywords and footnotes from the
+scores (the scSemiProfiler verdicts can change when the missing draws arrive).
+Run after that script and before generate_deck.py:
+
+    python3 tools/sec09_paired_validation.py
+    python3 tools/sync_sec09_text.py
+    python3 generate_deck.py
+
+Two kinds of spec slides are synced:
+  - "sec09_index": i       -> slide i of data/sec09_slide_text.json (section 9 main slides)
+  - "text_source": {"file": "data/<x>_slide_text.json", "index": i}
+                           -> slide i of that file (added 2026-10-02: data/sec09_extra_slide_text.json from
+                              tools/sec09_extra_metrics.py, data/sec07_rank_sweep_slide_text.json from
+                              tools/sec07_rank_sweep.py)
+
+Titles, keywords, footnote_full, numbers and (from footnote_short) the on-slide footnote
+are overwritten; if footnote_full changed, the script lists the slide so the
+short copy can be checked by hand (the deck build fails if it exceeds 2 lines).
+"""
+import json
+import sys
+from pathlib import Path
+
+DECK = Path(__file__).resolve().parents[1]
+SPEC = Path(sys.argv[1]) if len(sys.argv) > 1 else DECK / "data" / "slides_spec.json"
+SRC = DECK / "data" / "sec09_slide_text.json"
+# section-9 slides deliberately left out of the deck (index -> why); every other index must be used exactly once
+RETIRED = {2: "5 donors: LoRA vs scSemiProfiler — disease signal; superseded 2026-10-08 by tools/fig4_disease.py "
+              "(5-pair comparison without the bulk-broadcast baseline, partial r added)"}
+
+
+def copy_text(s: dict, g: dict, review: list) -> None:
+    figs = [str(Path(f).relative_to(DECK)) for f in g["figures"]]
+    have = [str(Path(f).relative_to(DECK)) if Path(f).is_absolute() else f for f in s["figures"]]
+    if figs != have:
+        raise SystemExit(f"figure mismatch for '{g['title']}': {figs} vs {s['figures']}")
+    s["figures"] = figs
+    s["title"] = g["title"]
+    s["keywords"] = g["keywords"]
+    if s.get("footnote_full", s.get("footnote")) != g["footnote"]:
+        review.append(g["title"])
+    s["footnote_full"] = g["footnote"]
+    if g.get("footnote_short"):
+        s["footnote"] = g["footnote_short"]
+    s["numbers"] = g["numbers"]   # quoted numbers + sources, kept in step with the slide text (2026-10-01)
+
+
+def main() -> None:
+    spec = json.loads(SPEC.read_text())
+    src = json.loads(SRC.read_text())["slides"]
+    review = []
+    n = 0
+    other: dict = {}
+    for s in spec["slides"]:
+        i = s.get("sec09_index")
+        if i is not None:
+            copy_text(s, src[i], review)
+            n += 1
+            continue
+        ts = s.get("text_source")
+        if ts:
+            f = DECK / ts["file"]
+            g = json.loads(f.read_text())["slides"]
+            copy_text(s, g[int(ts["index"])], review)
+            other.setdefault(ts["file"], set()).add(int(ts["index"]))
+    used = {s.get("sec09_index") for s in spec["slides"] if s.get("sec09_index") is not None}
+    if used & set(RETIRED) or n + len(RETIRED) != len(src) or src[2]["title"] != RETIRED[2].split(";")[0]:
+        raise SystemExit(f"spec has {n} sec09 slides + {len(RETIRED)} retired, source has {len(src)}")
+    for f, idx in other.items():
+        m = len(json.loads((DECK / f).read_text())["slides"])
+        if idx != set(range(m)):
+            raise SystemExit(f"spec uses slides {sorted(idx)} of {f}, which has {m}")
+    SPEC.write_text(json.dumps(spec, indent=2, ensure_ascii=False) + "\n")
+    print(f"synced {n} section 9 slides and " + ", ".join(f"{len(v)} from {k}" for k, v in other.items()))
+    for t in review:
+        print(f"REVIEW short footnote (source footnote changed): {t}")
+
+
+if __name__ == "__main__":
+    main()