run_repro.py

"""
run_repro.py
============
Reproduces the linear-theory claims of arXiv:2602.02908 ("A Random Matrix Theory
Perspective on the Consistency of Diffusion Models") and validates each analytic
deterministic-equivalence (DE) prediction against a Monte-Carlo (MC) ground truth
computed by resampling finite datasets.

Outputs (written to ./outputs/):
  * claimC*_*.csv     raw numbers behind every figure
  * claimC*_*.png     the reproduced figure
  * results_summary.json / results_summary.md   agreement metrics for the logbook

Run:
  python run_repro.py                 # default config
  python run_repro.py --config configs/repro.yaml
"""
from __future__ import annotations
import argparse, json, os, time
import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

import rmt_diffusion as rmt

OUT = os.path.join(os.path.dirname(__file__), "outputs")
os.makedirs(OUT, exist_ok=True)


def _save_csv(name, header, rows):
    import csv
    with open(os.path.join(OUT, name), "w", newline="") as f:
        w = csv.writer(f)
        w.writerow(header)
        w.writerows(rows)


def combined_mc(eigs, sigma2, n, R, x_vec, rng):
    """One pass over R dataset realizations, accumulating:
       diag_mean/diag_var  -> E[u_k^T M u_k], Var[.]   (shrinkage along PC, Fig 2C)
       resp_var            -> Var[u_k^T M x] for fixed x (anisotropy, Fig 3B)
       total_var           -> sum_ij Var[M_ij]         (global scaling, Fig 3D)
    """
    d = eigs.shape[0]; I = np.eye(d)
    diag = np.empty((R, d)); resp = np.empty((R, d))
    # Welford for full-matrix variance (memory-light)
    mean_M = np.zeros((d, d)); M2 = np.zeros((d, d))
    for r in range(R):
        C = rmt.sample_empirical_cov(eigs, n, rng)
        M = C @ np.linalg.solve(C + sigma2 * I, I)
        diag[r] = np.diag(M)
        resp[r] = M @ x_vec
        delta = M - mean_M; mean_M += delta / (r + 1); M2 += delta * (M - mean_M)
    total_var = float((M2 / (R - 1)).sum())
    return diag.mean(0), diag.var(0, ddof=1), resp.var(0, ddof=1), total_var


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default=None)
    args = ap.parse_args()

    cfg = dict(d=180, alpha=1.0, seed=0,
               c1_sigma2=list(np.logspace(-2, 1, 12)),
               c1_ns=[100, 400, 2000], c1_R=70,
               shr_sigma2=0.1, shr_n=300, shr_R=500,
               aniso_n=2000, aniso_R=900,
               scale_ns=[100, 200, 400, 800, 1600, 3200], scale_sigma2=0.1, scale_R=250,
               sqrt_ns=[200, 1000], sqrt_R=250)
    if args.config:
        import yaml
        loaded = yaml.safe_load(open(args.config)) or {}
        cfg.update({k: v for k, v in loaded.items() if v is not None})
    if cfg.get("c1_sigma2") is None:
        cfg["c1_sigma2"] = list(np.logspace(-2, 1, 12))

    rng = np.random.default_rng(cfg["seed"])
    d, alpha = cfg["d"], cfg["alpha"]
    eigs = rmt.power_law_spectrum(d, alpha=alpha)
    summary = {"paper": "arXiv:2602.02908", "d": d, "alpha": alpha, "seed": cfg["seed"],
               "spectrum": "power-law lambda_k = k^-alpha (natural-image-like)"}
    t0 = time.time()

    # ---------------------------------------------------------------- C1: kappa map + DE
    print("C1: renormalized noise scale kappa(sigma^2)  [Eq. 4 / Fig 2B]")
    plt.figure(figsize=(6, 4.2))
    c1_rows = []
    de_mc_relerr = []
    for n in cfg["c1_ns"]:
        gamma = d / n
        s2 = np.array(cfg["c1_sigma2"])
        kap = np.array([rmt.solve_kappa(x, eigs, gamma) for x in s2])
        plt.plot(s2, kap, marker="o", ms=3, label=f"n={n} (gamma={gamma:.2f})")
        # DE-vs-MC validation of the trace resolvent identity at each sigma^2
        for xi, ki in zip(s2, kap):
            de = rmt._normalized_trace_resolvent(eigs, ki)
            mc = rmt.mc_trace_resolvent(eigs, float(xi), n, R=cfg["c1_R"], rng=rng)
            de_mc_relerr.append(abs(de - mc) / mc)
            c1_rows.append([n, gamma, xi, ki, de, mc])
    plt.plot(cfg["c1_sigma2"], cfg["c1_sigma2"], "k--", lw=1, label="identity (infinite data)")
    plt.xscale("log"); plt.yscale("log"); plt.xlabel(r"$\sigma^2$"); plt.ylabel(r"$\kappa(\sigma^2)$")
    plt.title("C1  Renormalized noise scale (finite data push $\\kappa \\geq \\sigma^2$)")
    plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC1_kappa.png"), dpi=130)
    plt.close()
    _save_csv("claimC1_kappa.csv", ["n", "gamma", "sigma2", "kappa", "trace_DE", "trace_MC"], c1_rows)
    summary["C1_trace_DE_vs_MC_median_relerr"] = float(np.median(de_mc_relerr))
    summary["C1_kappa_ge_sigma2_always"] = bool(all(r[3] >= r[2] - 1e-9 for r in c1_rows))

    # ---------------------------------------------------- C2/C3: shrinkage along PC (Fig 2C)
    print("C2/C3: expected shrinkage along PCs + overshrinkage  [Result 4.1 / Fig 2C]")
    s2 = cfg["shr_sigma2"]; n = cfg["shr_n"]
    x_probe = rng.standard_normal(d) * np.sqrt(eigs + s2)          # a generic noised sample
    diag_mean, diag_var, resp_var, total_var = combined_mc(eigs, s2, n, cfg["shr_R"], x_probe, rng)
    kappa, renorm, naive = rmt.predict_shrinkage_along_pc(eigs, s2, d / n)
    # agreement between MC diagonal shrinkage and the DE (renormalized) prediction
    shr_relerr = np.median(np.abs(diag_mean - renorm) / np.abs(renorm))
    shr_relerr_naive = np.median(np.abs(diag_mean - naive) / np.abs(naive))
    plt.figure(figsize=(6, 4.2))
    order = np.argsort(eigs)
    plt.plot(eigs[order], naive[order], "g--", lw=1.5, label=r"naive $\lambda/(\lambda+\sigma^2)$ (infinite data)")
    plt.plot(eigs[order], renorm[order], "b-", lw=1.5, label=r"DE $\lambda/(\lambda+\kappa)$ (finite-data theory)")
    plt.plot(eigs[order], diag_mean[order], "r.", ms=5, label="MC empirical denoiser")
    plt.xscale("log"); plt.xlabel(r"population eigenvalue $\lambda_k$"); plt.ylabel("shrinkage factor")
    plt.title(f"C3  Overshrinkage of low modes ($\\kappa$={kappa:.3f} > $\\sigma^2$={s2})")
    plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC3_shrinkage.png"), dpi=130)
    plt.close()
    _save_csv("claimC3_shrinkage.csv", ["lambda_k", "MC_shrinkage", "DE_renorm", "naive_pop"],
              [[eigs[k], diag_mean[k], renorm[k], naive[k]] for k in range(d)])
    summary["C3_kappa"] = float(kappa)
    summary["C3_shrinkage_MC_vs_DE_median_relerr"] = float(shr_relerr)
    summary["C3_shrinkage_MC_vs_naive_median_relerr"] = float(shr_relerr_naive)

    # ------------------------------------------------------- C4: anisotropy variance (Fig 3B)
    print("C4: anisotropy of denoiser variance chi(lambda,kappa)  [Result 4.2 / Fig 3B]")
    n = cfg["aniso_n"]
    x_probe2 = rng.standard_normal(d) * np.sqrt(eigs + s2)
    _, _, resp_var2, _ = combined_mc(eigs, s2, n, cfg["aniso_R"], x_probe2, rng)
    kappa4, var_pred, chi, inhom, peak_val = rmt.predict_denoiser_variance_along_pc(eigs, s2, n, x_probe2)
    # shape agreement (correlation) and peak-location check
    corr = float(np.corrcoef(resp_var2, var_pred)[0, 1])
    k_peak_mc = int(np.argmax(resp_var2)); k_peak_th = int(np.argmax(chi))
    lam_peak_mc, lam_peak_th = float(eigs[k_peak_mc]), float(eigs[k_peak_th])
    plt.figure(figsize=(6, 4.2))
    plt.plot(eigs, var_pred, "b-", lw=1.5, label="DE prediction (Result 4.2)")
    plt.plot(eigs, resp_var2, "r.", ms=5, label="MC variance across data splits")
    plt.axvline(kappa4, color="k", ls=":", lw=1, label=r"$\lambda=\kappa$ (predicted peak)")
    plt.xscale("log"); plt.xlabel(r"population eigenvalue $\lambda_k$")
    plt.ylabel(r"Var$[u_k^\top D^*_{\hat\Sigma}(x)]$")
    plt.title("C4  Anisotropy: variance peaks where $\\lambda_k \\approx \\kappa$")
    plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC4_anisotropy.png"), dpi=130)
    plt.close()
    _save_csv("claimC4_anisotropy.csv", ["lambda_k", "MC_var", "DE_var", "chi"],
              [[eigs[k], resp_var2[k], var_pred[k], chi[k]] for k in range(d)])
    summary["C4_kappa"] = float(kappa4)
    summary["C4_shape_corr_MC_vs_DE"] = corr
    summary["C4_peak_lambda_MC"] = lam_peak_mc
    summary["C4_peak_lambda_theory_eq_kappa"] = lam_peak_th
    summary["C4_peak_matches_kappa"] = bool(abs(np.log(lam_peak_mc) - np.log(kappa4)) < 0.5)

    # --------------------------------------------------------- C5: global 1/n scaling (Fig 3D)
    print("C5: global scaling of consistency ~ 1/n  [Fig 3D]")
    ns = cfg["scale_ns"]; tv = []
    for nn in ns:
        _, _, _, total = combined_mc(eigs, cfg["scale_sigma2"], nn, cfg["scale_R"], x_probe, rng)
        tv.append(total)
    tv = np.array(tv); ns_a = np.array(ns, float)
    # fit slope of log(total_var) vs log(n) on the large-n half (renormalization-free regime)
    half = len(ns) // 2
    slope = float(np.polyfit(np.log(ns_a[half:]), np.log(tv[half:]), 1)[0])
    plt.figure(figsize=(6, 4.2))
    plt.plot(ns_a, tv, "ro-", ms=4, label="MC total denoiser variance")
    plt.plot(ns_a, tv[half] * (ns_a / ns_a[half]) ** (-1.0), "k--", lw=1, label=r"$\propto 1/n$ reference")
    plt.xscale("log"); plt.yscale("log"); plt.xlabel("dataset size n"); plt.ylabel("total variance")
    plt.title(f"C5  Consistency improves as ~1/n  (fitted slope={slope:.2f})")
    plt.legend(fontsize=8); plt.tight_layout(); plt.savefig(os.path.join(OUT, "claimC5_scaling.png"), dpi=130)
    plt.close()
    _save_csv("claimC5_scaling.csv", ["n", "total_variance"], [[ns[i], tv[i]] for i in range(len(ns))])
    summary["C5_large_n_loglog_slope"] = slope
    summary["C5_slope_near_minus1"] = bool(abs(slope + 1.0) < 0.15)

    # ------------------------------------------------ C6: sampling-map overshrinkage +
    #    DETERMINISTIC-EQUIVALENCE for the EXPECTATION of Sigma_hat^{1/2}  (Result 5.1 / Fig 4A)
    print("C6: sampling-map sqrt-covariance overshrinkage + DE expectation  [Result 5.1 / Fig 4A]")
    plt.figure(figsize=(6, 4.2))
    ideal = np.sqrt(eigs)          # ideal infinite-data sampling-map scaling
    c6_rows = []
    order = np.argsort(eigs)
    plt.plot(eigs[order], ideal[order], "k-", lw=1.5, label=r"ideal $\sqrt{\lambda_k}$ (infinite data)")
    c6_de_relerr = []
    for nn in cfg["sqrt_ns"]:
        mc_scale = rmt.mc_sqrt_cov_scaling(eigs, nn, cfg["sqrt_R"], rng)
        de_scale = rmt.predict_sqrt_cov_scaling(eigs, nn)[1]     # DE prediction (Result 5.1)
        rel = np.abs(de_scale - mc_scale) / np.abs(mc_scale)
        c6_de_relerr.append(float(np.median(rel)))
        p = plt.plot(eigs[order], mc_scale[order], ".", ms=4, label=f"MC, n={nn}")[0]
        plt.plot(eigs[order], de_scale[order], "-", lw=1.0, color=p.get_color(),
                 label=f"DE, n={nn}")
        for k in range(d):
            c6_rows.append([nn, eigs[k], ideal[k], mc_scale[k], de_scale[k]])
    plt.xscale("log"); plt.yscale("log"); plt.xlabel(r"population eigenvalue $\lambda_k$")
    plt.ylabel(r"$u_k^\top \hat\Sigma^{1/2} u_k$")
    plt.title("C6  Sampling-map expectation: DE vs MC (overshrinks $\\sqrt{\\lambda_k}$ at low modes)")
    plt.legend(fontsize=7, ncol=2); plt.tight_layout()
    plt.savefig(os.path.join(OUT, "claimC6_sqrtcov.png"), dpi=130)
    plt.close()
    _save_csv("claimC6_sqrtcov.csv", ["n", "lambda_k", "ideal_sqrt", "MC_scale", "DE_scale"], c6_rows)
    mc_small = rmt.mc_sqrt_cov_scaling(eigs, cfg["sqrt_ns"][0], cfg["sqrt_R"], rng)
    low = order[d // 2:]
    summary["C6_low_mode_overshrink_ratio_small_n"] = float(np.mean(mc_small[low] / ideal[low]))
    summary["C6_sqrtmap_expectation_DE_vs_MC_median_relerr"] = float(np.median(c6_de_relerr))

    # ------------------------------------------------ C7: sampling-map VARIANCE over
    #    trajectories: anisotropy + 1/n decay  (Result 5.2)
    print("C7: sampling-map variance over trajectories  [Result 5.2]")
    ns_var = cfg["scale_ns"]
    tot_var, c7_rows = [], []
    for nn in ns_var:
        v = rmt.mc_sqrtmap_variance(eigs, nn, cfg["sqrt_R"], rng)
        tot_var.append(float(v.sum()))
        for k in range(d):
            c7_rows.append([nn, eigs[k], v[k], rmt.predict_sqrtmap_variance(eigs, nn)[k]])
    tot_var = np.array(tot_var)
    var_slope = float(np.polyfit(np.log(ns_var), np.log(tot_var), 1)[0])
    # per-mode DE check at a mid n (leading-order lambda_k/(2n)); anisotropy corr
    n_mid = ns_var[len(ns_var) // 2]
    v_mid = rmt.mc_sqrtmap_variance(eigs, n_mid, cfg["sqrt_R"], rng)
    de_mid = rmt.predict_sqrtmap_variance(eigs, n_mid)
    top = order[:40]                                  # well-estimated (high-variance) modes
    var_relerr = float(np.median(np.abs(v_mid[top] - de_mid[top]) / de_mid[top]))
    aniso_corr = float(np.corrcoef(np.log(v_mid[:60]), np.log(eigs[:60]))[0, 1])
    plt.figure(figsize=(6, 4.2))
    plt.loglog(ns_var, tot_var, "o-", label=f"MC total sampling-map variance (slope {var_slope:.2f})")
    plt.loglog(ns_var, tot_var[0] * ns_var[0] / np.array(ns_var), "k--", label=r"$1/n$ reference")
    plt.xlabel("dataset size $n$"); plt.ylabel(r"$\sum_k \mathrm{Var}[u_k^\top\hat\Sigma^{1/2}u_k]$")
    plt.title("C7  Sampling-map (trajectory) variance decays as $1/n$  [Result 5.2]")
    plt.legend(fontsize=8); plt.tight_layout()
    plt.savefig(os.path.join(OUT, "claimC7_sqrtmap_variance.png"), dpi=130)
    plt.close()
    _save_csv("claimC7_sqrtmap_variance.csv", ["n", "lambda_k", "MC_var", "DE_var_leading"], c7_rows)
    summary["C7_sqrtmap_variance_loglog_slope"] = var_slope
    summary["C7_sqrtmap_variance_anisotropy_corr"] = aniso_corr
    summary["C7_sqrtmap_variance_DE_vs_MC_median_relerr_topmodes"] = var_relerr

    # ------------------------------------------------ F1: linear-diffusion SPLIT CONSISTENCY
    #    two non-overlapping splits -> similar samples from the same seed  (Fig 1)
    print("F1: linear-diffusion consistency across non-overlapping data splits  [Fig 1]")
    ns_con = cfg["scale_ns"]
    n_seeds = cfg.get("consistency_seeds", 400)
    cos_list, dev_list, f1_rows = [], [], []
    for nn in ns_con:
        c, d2 = rmt.mc_split_consistency(eigs, nn, n_seeds, rng)
        cos_list.append(c); dev_list.append(d2)
        f1_rows.append([nn, c, d2])
    dev_slope = float(np.polyfit(np.log(ns_con), np.log(dev_list), 1)[0])
    fig, ax1 = plt.subplots(figsize=(6, 4.2))
    ax1.semilogx(ns_con, cos_list, "o-", color="C0")
    ax1.set_xlabel("dataset size $n$ per split")
    ax1.set_ylabel("mean cross-split cosine similarity", color="C0")
    ax1.tick_params(axis="y", labelcolor="C0"); ax1.set_ylim(0.6, 1.02)
    ax2 = ax1.twinx()
    ax2.loglog(ns_con, dev_list, "s--", color="C3")
    ax2.set_ylabel(r"rel. squared deviation $\|x_A-x_B\|^2/\|x_A\|\|x_B\|$", color="C3")
    ax2.tick_params(axis="y", labelcolor="C3")
    ax1.set_title(f"F1  Non-overlapping splits generate similar samples (deviation $\\sim n^{{{dev_slope:.2f}}}$)")
    fig.tight_layout(); plt.savefig(os.path.join(OUT, "claimF1_split_consistency.png"), dpi=130)
    plt.close()
    _save_csv("claimF1_split_consistency.csv", ["n", "mean_cosine", "mean_rel_sq_deviation"], f1_rows)
    summary["F1_cosine_small_n"] = float(cos_list[0])
    summary["F1_cosine_large_n"] = float(cos_list[-1])
    summary["F1_deviation_loglog_slope"] = dev_slope

    summary["runtime_sec"] = round(time.time() - t0, 1)
    json.dump(summary, open(os.path.join(OUT, "results_summary.json"), "w"), indent=2)

    # human-readable summary
    with open(os.path.join(OUT, "results_summary.md"), "w") as f:
        f.write("# Reproduction results — arXiv:2602.02908 (linear theory)\n\n")
        f.write(f"Population: d={d}, power-law spectrum (alpha={alpha}); seed={cfg['seed']}; "
                f"runtime {summary['runtime_sec']}s on CPU.\n\n")
        f.write("| Claim | Check | Result |\n|---|---|---|\n")
        f.write(f"| C1 | kappa >= sigma^2 always | {summary['C1_kappa_ge_sigma2_always']} |\n")
        f.write(f"| C1 | trace-resolvent DE vs MC (median rel.err) | {summary['C1_trace_DE_vs_MC_median_relerr']:.2%} |\n")
        f.write(f"| C3 | MC shrinkage vs DE-renormalized (median rel.err) | {summary['C3_shrinkage_MC_vs_DE_median_relerr']:.2%} |\n")
        f.write(f"| C3 | MC shrinkage vs naive population (median rel.err) | {summary['C3_shrinkage_MC_vs_naive_median_relerr']:.2%} |\n")
        f.write(f"| C4 | anisotropy shape corr (MC vs DE) | {summary['C4_shape_corr_MC_vs_DE']:.3f} |\n")
        f.write(f"| C4 | variance peak at lambda≈kappa | MC λ={summary['C4_peak_lambda_MC']:.3f} vs κ={summary['C4_kappa']:.3f} ({summary['C4_peak_matches_kappa']}) |\n")
        f.write(f"| C5 | large-n log-log slope (≈ -1) | {summary['C5_large_n_loglog_slope']:.2f} |\n")
        f.write(f"| C6 | low-mode sqrt-cov ratio < 1 (overshrink), small n | {summary['C6_low_mode_overshrink_ratio_small_n']:.3f} |\n")
        f.write(f"| C6 | sampling-map expectation DE vs MC (Result 5.1, median rel.err) | {summary['C6_sqrtmap_expectation_DE_vs_MC_median_relerr']:.2%} |\n")
        f.write(f"| C7 | sampling-map trajectory variance 1/n slope (Result 5.2) | {summary['C7_sqrtmap_variance_loglog_slope']:.2f} |\n")
        f.write(f"| C7 | sampling-map variance anisotropy corr (Var vs lambda) | {summary['C7_sqrtmap_variance_anisotropy_corr']:.3f} |\n")
        f.write(f"| F1 | cross-split sample cosine, n={cfg['scale_ns'][0]} -> {cfg['scale_ns'][-1]} (Fig 1) | {summary['F1_cosine_small_n']:.3f} -> {summary['F1_cosine_large_n']:.3f} |\n")
        f.write(f"| F1 | cross-split deviation 1/n slope (consistency improves) | {summary['F1_deviation_loglog_slope']:.2f} |\n")

    print("\n=== SUMMARY ===")
    print(open(os.path.join(OUT, "results_summary.md")).read())


if __name__ == "__main__":
    main()