Add reproduction scripts

scripts/analyze.py

@@ -0,0 +1,267 @@
+"""Analysis + figures for the reproduction of arXiv:2602.02431.
+
+Reads the raw sweep CSVs in results/ and writes
+  * aggregated CSVs (mean +- sem over seeds, thresholds, log-d fits)
+  * interactive plotly figures (figures/*.html, plotly loaded from CDN)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from scipy.interpolate import PchipInterpolator
+
+RES = "results"
+FIG = "figures"
+PALETTE = ["#3b1c62", "#5b2c8d", "#8b2fa0", "#b52d7f", "#d4426a", "#e8663c",
+           "#f39325", "#f7c325"]
+
+
+def _c(i, n):
+    return PALETTE[int(round(i * (len(PALETTE) - 1) / max(n - 1, 1)))]
+
+
+def agg(df, xcol="delta"):
+    g = df.groupby(["d", xcol])["sq_overlap"]
+    out = g.agg(["mean", "std", "count"]).reset_index()
+    out["sem"] = out["std"] / np.sqrt(out["count"].clip(lower=1))
+    return out
+
+
+def threshold(x, y, target, smooth=True):
+    """Smallest x at which the (monotonised) curve y(x) reaches `target`."""
+    x = np.asarray(x, float)
+    y = np.asarray(y, float)
+    if smooth and len(y) >= 5:
+        k = np.array([0.25, 0.5, 0.25])
+        y = np.convolve(np.pad(y, 1, mode="edge"), k, mode="valid")
+    ymon = np.maximum.accumulate(y)
+    if ymon[-1] < target or ymon[0] > target:
+        return np.nan
+    f = PchipInterpolator(x, ymon - target)
+    lo = np.searchsorted(ymon, target)
+    a, b = x[max(lo - 1, 0)], x[min(lo, len(x) - 1)]
+    if a == b:
+        return float(a)
+    xs = np.linspace(a, b, 4001)
+    vals = f(xs)
+    idx = np.argmin(np.abs(vals))
+    return float(xs[idx])
+
+
+def linfit(x, y):
+    x, y = np.asarray(x, float), np.asarray(y, float)
+    m = np.isfinite(x) & np.isfinite(y)
+    x, y = x[m], y[m]
+    if len(x) < 2:
+        return dict(slope=np.nan, intercept=np.nan, r2=np.nan, n=len(x))
+    b, a = np.polyfit(x, y, 1)
+    yhat = a + b * x
+    ss_res = float(((y - yhat) ** 2).sum())
+    ss_tot = float(((y - y.mean()) ** 2).sum())
+    return dict(slope=float(b), intercept=float(a),
+                r2=float(1 - ss_res / ss_tot) if ss_tot > 0 else np.nan, n=int(len(x)))
+
+
+def write_fig(fig, name):
+    os.makedirs(FIG, exist_ok=True)
+    path = os.path.join(FIG, name + ".html")
+    fig.write_html(path, include_plotlyjs="cdn", full_html=True)
+    print("wrote", path)
+    return path
+
+
+def overlap_fig(a, title, ytitle="Squared overlap ⟨θ*, θ̂⟩²", xtitle="δ = n/d",
+                logx=False):
+    dims = sorted(a["d"].unique())
+    fig = go.Figure()
+    for i, d in enumerate(dims):
+        s = a[a["d"] == d].sort_values(a.columns[1])
+        x = s[s.columns[1]]
+        fig.add_trace(go.Scatter(
+            x=x, y=s["mean"], mode="lines+markers", name=f"d={d}",
+            line=dict(color=_c(i, len(dims)), width=2),
+            marker=dict(size=6),
+            error_y=dict(type="data", array=s["sem"], visible=True, thickness=1,
+                         width=0, color=_c(i, len(dims)))))
+    fig.update_layout(title=title, xaxis_title=xtitle, yaxis_title=ytitle,
+                      template="plotly_white", height=460,
+                      legend=dict(orientation="v", x=1.02, y=1))
+    if logx:
+        fig.update_xaxes(type="log")
+    return fig
+
+
+def thresholds_fig(rows, title, ytitle="Threshold δ = n/d"):
+    fig = go.Figure()
+    tgts = sorted({r["target"] for r in rows})
+    for i, t in enumerate(tgts):
+        sub = [r for r in rows if r["target"] == t and np.isfinite(r["value"])]
+        if not sub:
+            continue
+        x = [r["logd"] for r in sub]
+        y = [r["value"] for r in sub]
+        f = linfit(x, y)
+        col = _c(i, len(tgts))
+        fig.add_trace(go.Scatter(x=x, y=y, mode="markers", marker=dict(size=9, color=col),
+                                 name=f"overlap={t} (R²={f['r2']:.3f})"))
+        xs = np.linspace(min(x), max(x), 10)
+        fig.add_trace(go.Scatter(x=xs, y=f["intercept"] + f["slope"] * xs, mode="lines",
+                                 line=dict(color=col, width=2), showlegend=False))
+    fig.update_layout(title=title, xaxis_title="log d", yaxis_title=ytitle,
+                      template="plotly_white", height=460)
+    return fig
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--targets", default="0.1,0.2,0.3,0.4,0.5")
+    args = ap.parse_args()
+    targets = [float(v) for v in args.targets.split(",")]
+    os.makedirs(FIG, exist_ok=True)
+    summary = {}
+
+    # ---------------- spherical sweeps (Claims 1, 2, 5) ---------------------
+    thr_rows = []
+    for act, label in (("quad", "quadratic σ(z)=z²"),
+                       ("trunc", "truncated σ(z)=min(z²,M), M=8")):
+        path = f"{RES}/sweep_{act}.csv"
+        if not os.path.exists(path):
+            continue
+        df = pd.read_csv(path)
+        a = agg(df)
+        a.to_csv(f"{RES}/agg_{act}.csv", index=False)
+        write_fig(overlap_fig(a, f"Full-batch spherical GD, {label}"), f"overlap_{act}")
+        for d in sorted(a["d"].unique()):
+            s = a[a["d"] == d].sort_values("delta")
+            for t in targets:
+                thr_rows.append(dict(method="full-batch", act=act, d=int(d),
+                                     logd=math.log(d), target=t,
+                                     value=threshold(s["delta"], s["mean"], t)))
+        # bimodality diagnostic: fraction of seeds that reach non-trivial overlap
+        fr = (df.assign(ok=(df["sq_overlap"] > 0.25).astype(float))
+                .groupby(["d", "delta"])["ok"].mean().reset_index())
+        fr.to_csv(f"{RES}/success_frac_{act}.csv", index=False)
+
+    # ---------------- one-pass SGD baseline (Claim 5) ----------------------
+    for act in ("trunc", "quad"):
+        p = f"{RES}/sweep_online_{act}.csv"
+        if not os.path.exists(p):
+            continue
+        df = pd.read_csv(p)
+        # the Arous et al. lower bound holds for *any* step size eta <~ 1/d, so the
+        # fair baseline is the envelope over the eta = c/d grid at each (d, n).
+        a = (df.groupby(["d", "delta"])["sq_overlap"].max().reset_index()
+               .rename(columns={"sq_overlap": "mean"}))
+        a["sem"] = 0.0
+        a.to_csv(f"{RES}/agg_online_{act}.csv", index=False)
+        write_fig(overlap_fig(
+            a, f"One-pass (online) spherical SGD, {act} σ — best η over c/d grid"),
+            f"overlap_online_{act}")
+        for d in sorted(a["d"].unique()):
+            s = a[a["d"] == d].sort_values("delta")
+            for t in targets:
+                thr_rows.append(dict(method="one-pass-sgd", act=act, d=int(d),
+                                     logd=math.log(d), target=t,
+                                     value=threshold(s["delta"], s["mean"], t)))
+
+    if thr_rows:
+        tdf = pd.DataFrame(thr_rows)
+        tdf.to_csv(f"{RES}/thresholds.csv", index=False)
+        fits = []
+        for (meth, act), g in tdf.groupby(["method", "act"]):
+            for t in targets:
+                sub = g[g["target"] == t]
+                f = linfit(sub["logd"], sub["value"])
+                f.update(method=meth, act=act, target=t)
+                fits.append(f)
+            rows = [r for _, r in g.iterrows()]
+            write_fig(
+                thresholds_fig([dict(target=r["target"], logd=r["logd"], value=r["value"])
+                                for r in rows],
+                               f"Sample-complexity threshold vs log d — {meth}, {act}"),
+                f"threshold_{meth.replace('-', '_')}_{act}")
+        pd.DataFrame(fits).to_csv(f"{RES}/threshold_fits.csv", index=False)
+        summary["threshold_fits"] = fits
+
+        # Claim 5: side-by-side separation figure
+        combos = [("full-batch", "trunc", "full-batch GD, truncated σ", PALETTE[1]),
+                  ("full-batch", "quad", "full-batch GD, quadratic σ", PALETTE[3]),
+                  ("one-pass-sgd", "trunc", "one-pass SGD, truncated σ", PALETTE[5]),
+                  ("one-pass-sgd", "quad", "one-pass SGD, quadratic σ", PALETTE[6])]
+        for tg in (0.3, 0.5):
+            fig = go.Figure()
+            for meth, act, lab, col in combos:
+                sub = tdf[(tdf["method"] == meth) & (tdf["act"] == act)
+                          & (tdf["target"] == tg)].sort_values("logd")
+                if sub.empty or not np.isfinite(sub["value"]).any():
+                    continue
+                f = linfit(sub["logd"], sub["value"])
+                fig.add_trace(go.Scatter(x=sub["logd"], y=sub["value"], mode="markers",
+                                         marker=dict(size=10, color=col),
+                                         name=f"{lab} — slope {f['slope']:.2f}, R²={f['r2']:.3f}"))
+                xs = np.linspace(sub["logd"].min(), sub["logd"].max(), 10)
+                fig.add_trace(go.Scatter(x=xs, y=f["intercept"] + f["slope"] * xs,
+                                         mode="lines", line=dict(color=col, width=2),
+                                         showlegend=False))
+            fig.update_layout(
+                title=f"Sample complexity δ = n/d for squared overlap {tg}: "
+                      "full-batch vs one-pass",
+                xaxis_title="log d", yaxis_title="threshold δ = n/d",
+                template="plotly_white", height=470,
+                legend=dict(orientation="h", yanchor="bottom", y=-0.42))
+            write_fig(fig, f"separation_target{str(tg).replace('.', '')}")
+
+    # ---- direct test of the n ≍ d log d scaling (Theorem 3.1 vs 3.2) --------
+    scal = []
+    for act in ("quad", "trunc"):
+        p = f"{RES}/agg_{act}.csv"
+        if not os.path.exists(p):
+            continue
+        a = pd.read_csv(p)
+        for d in sorted(a["d"].unique()):
+            s = a[a["d"] == d].sort_values("delta")
+            f = PchipInterpolator(s["delta"].values, s["mean"].values)
+            for mode, dl in ([("fixed δ=4", 4.0), ("fixed δ=8", 8.0),
+                              ("δ=1.2·log d", 1.2 * math.log(d))]):
+                if s["delta"].min() <= dl <= s["delta"].max():
+                    scal.append(dict(act=act, d=int(d), logd=math.log(d), mode=mode,
+                                     delta=round(dl, 3), mean=float(f(dl))))
+    if scal:
+        sdf = pd.DataFrame(scal)
+        sdf.to_csv(f"{RES}/scaling_collapse.csv", index=False)
+        fig = go.Figure()
+        styles = {("quad", "fixed δ=4"): (PALETTE[5], "solid"),
+                  ("quad", "fixed δ=8"): (PALETTE[6], "solid"),
+                  ("quad", "δ=1.2·log d"): (PALETTE[1], "dash"),
+                  ("trunc", "fixed δ=4"): (PALETTE[3], "dot"),
+                  ("trunc", "fixed δ=8"): (PALETTE[0], "dot")}
+        for (act, mode), g in sdf.groupby(["act", "mode"]):
+            if (act, mode) not in styles:
+                continue
+            col, dash = styles[(act, mode)]
+            g = g.sort_values("logd")
+            fig.add_trace(go.Scatter(x=g["logd"], y=g["mean"], mode="lines+markers",
+                                     name=f"{act}, {mode}",
+                                     line=dict(color=col, width=2, dash=dash)))
+        fig.update_layout(
+            title="Overlap along n ∝ d (fixed δ) vs n ∝ d log d — quadratic vs truncated σ",
+            xaxis_title="log d", yaxis_title="Squared overlap ⟨θ*, θ̂⟩²",
+            template="plotly_white", height=470,
+            legend=dict(orientation="h", yanchor="bottom", y=-0.38))
+        write_fig(fig, "scaling_collapse")
+        summary["scaling_collapse"] = scal
+
+    with open(f"{RES}/analysis_summary.json", "w") as f:
+        json.dump(summary, f, indent=2, default=float)
+    print(json.dumps(summary.get("threshold_fits", []), indent=2, default=float)[:4000])
+
+
+if __name__ == "__main__":
+    main()

scripts/analyze_audit.py

@@ -0,0 +1,165 @@
+"""Figures for the numerical audits of the spectral statements (Claims 1 and 2)."""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+
+from analyze import PALETTE, _c, write_fig, linfit
+
+RES = "results"
+
+
+def main():
+    out = {}
+    a = pd.read_csv(f"{RES}/audit_spectrum.csv")
+    dims = sorted(a["d"].unique())
+
+    # --- lambda1(A*): diverges for quadratic, converges to 6 for truncated -----
+    fig = go.Figure()
+    for i, d in enumerate(dims):
+        q = a[(a["act"] == "quad") & (a["d"] == d)].groupby("delta")["lam1"].mean().reset_index()
+        t = a[(a["act"] == "trunc") & (a["M"] == 8.0) & (a["d"] == d)] \
+            .groupby("delta")["lam1"].mean().reset_index()
+        fig.add_trace(go.Scatter(x=q["delta"], y=q["lam1"], mode="lines+markers",
+                                 name=f"quad d={d}", line=dict(color=_c(i, len(dims)), dash="dash")))
+        fig.add_trace(go.Scatter(x=t["delta"], y=t["lam1"], mode="lines+markers",
+                                 name=f"trunc d={d}", line=dict(color=_c(i, len(dims)))))
+    fig.add_hline(y=6, line_dash="dot", line_color="#111",
+                  annotation_text="population λ₁ = 6")
+    fig.update_layout(title="λ₁(A*) vs δ = n/d — quadratic (dashed) vs truncated M=8 (solid)",
+                      xaxis_title="δ = n/d", yaxis_title="λ₁(A*)", xaxis_type="log",
+                      yaxis_type="log", template="plotly_white", height=470)
+    write_fig(fig, "audit_lam1")
+
+    # --- the eq. (3.13) error: |lam1-6| + |lam2-2| vs the claimed rate ---------
+    t = a[(a["act"] == "trunc")].copy()
+    t["err"] = (t["lam1"] - 6).abs() + (t["lam2"] - 2).abs()
+    t["rate"] = np.exp(-t["M"] / 3) + t["M"] * np.sqrt(t["d"] / t["n"])
+    g = t.groupby(["M", "delta", "d"])[["err", "rate"]].mean().reset_index()
+    g["C"] = g["err"] / g["rate"]
+    g.to_csv(f"{RES}/audit_eq313.csv", index=False)
+    fig = go.Figure()
+    Ms = sorted(g["M"].unique())
+    for i, M in enumerate(Ms):
+        s = g[g["M"] == M]
+        fig.add_trace(go.Scatter(x=s["rate"], y=s["err"], mode="markers",
+                                 marker=dict(size=9, color=_c(i, len(Ms))), name=f"M={M:g}"))
+    lim = [float(g["rate"].min()) * 0.8, float(g["rate"].max()) * 1.2]
+    for C, dash in ((1.0, "dot"), (0.5, "dash")):
+        fig.add_trace(go.Scatter(x=lim, y=[C * lim[0], C * lim[1]], mode="lines",
+                                 line=dict(color="#444", dash=dash), name=f"C = {C}"))
+    fig.update_layout(
+        title="Eq. (3.13) audit: |λ₁−6| + |λ₂−2| vs C(e^(−M/3) + M√(d/n))",
+        xaxis_title="e^(−M/3) + M√(d/n)", yaxis_title="|λ₁−6| + |λ₂−2|",
+        xaxis_type="log", yaxis_type="log", template="plotly_white", height=470)
+    write_fig(fig, "audit_eq313")
+    out["eq313_max_C"] = float(g["C"].max())
+    out["eq313_max_C_largedelta"] = float(g[g["delta"] >= 16]["C"].max())
+
+    # --- uniform-in-theta BBP --------------------------------------------------
+    b = pd.read_csv(f"{RES}/audit_uniform_bbp.csv")
+    bt = b[(b["act"] == "trunc") & (b["M"] == 8.0)].copy()
+    bt["kind"] = np.where(bt["theta"].str.startswith("random"), "random θ", bt["theta"])
+    fig = go.Figure()
+    kinds = ["random θ", "theta_star", "adversarial"]
+    cols = {"random θ": PALETTE[1], "theta_star": PALETTE[4], "adversarial": PALETTE[6]}
+    for k in kinds:
+        s = bt[bt["kind"] == k]
+        for j, col in enumerate(("lam1", "lam2")):
+            fig.add_trace(go.Scatter(
+                x=s["delta"], y=s[col], mode="markers",
+                marker=dict(size=11, color=cols[k], symbol="circle" if j == 0 else "x"),
+                name=f"{k} — λ{j+1}", legendgroup=k, showlegend=True))
+    fig.add_hline(y=6, line_dash="dot", line_color="#111")
+    fig.add_hline(y=2, line_dash="dot", line_color="#111")
+    fig.update_layout(
+        title="Uniform-in-θ BBP transition of A(θ): λ₁ (circles) and λ₂ (crosses), truncated M=8",
+        xaxis_title="δ = n/d", yaxis_title="eigenvalue of A(θ)", xaxis_type="log",
+        template="plotly_white", height=470)
+    write_fig(fig, "audit_uniform_bbp")
+    s64 = bt[bt["delta"] == 64.0]
+    out["bbp_delta64"] = dict(lam1_min=float(s64["lam1"].min()), lam1_max=float(s64["lam1"].max()),
+                              lam2_min=float(s64["lam2"].min()), lam2_max=float(s64["lam2"].max()),
+                              ov_min=float(s64["sq_overlap_v1"].min()),
+                              ov_max=float(s64["sq_overlap_v1"].max()))
+
+    # --- indicator mass -------------------------------------------------------
+    c = pd.read_csv(f"{RES}/audit_indicator.csv")
+    ct = c[c["act"] == "trunc"].copy()
+    ct["kind"] = np.where(ct["theta"].str.startswith("random"), "random θ", ct["theta"])
+    fig = go.Figure()
+    for i, k in enumerate(["random θ", "theta_star", "adversarial"]):
+        s = ct[ct["kind"] == k]
+        fig.add_trace(go.Box(x=s["M"], y=s["ratio"], name=k,
+                             marker_color=[PALETTE[1], PALETTE[4], PALETTE[6]][i]))
+    fig.add_hline(y=1.0, line_dash="dot", line_color="#111",
+                  annotation_text="bound with C = 1")
+    fig.update_layout(
+        title="Uniform indicator-mass bound: measured mass ÷ (e^(−M/2) + √(d/n)·log(n/d))",
+        xaxis_title="M", yaxis_title="ratio", template="plotly_white", height=440,
+        boxmode="group")
+    write_fig(fig, "audit_indicator")
+    out["indicator_max_ratio"] = float(ct["ratio"].max())
+    out["indicator_max_ratio_adv"] = float(ct[ct["kind"] == "adversarial"]["ratio"].max())
+
+    # --- Theorem 3.2 deficit bound --------------------------------------------
+    th = pd.read_csv(f"{RES}/thm32_bound.csv")
+    gg = th.groupby(["M", "delta"])[["deficit", "rate", "C_implied"]].mean().reset_index()
+    fig = go.Figure()
+    Ms = sorted(gg["M"].unique())
+    for i, M in enumerate(Ms):
+        s = gg[gg["M"] == M]
+        fig.add_trace(go.Scatter(x=s["rate"], y=s["deficit"], mode="markers+lines",
+                                 marker=dict(size=10, color=_c(i, len(Ms))),
+                                 line=dict(color=_c(i, len(Ms))), name=f"M={M:g}"))
+    lim = [float(gg["rate"].min()) * 0.9, float(gg["rate"].max()) * 1.1]
+    fig.add_trace(go.Scatter(x=lim, y=lim, mode="lines", line=dict(color="#444", dash="dot"),
+                             name="C = 1"))
+    fig.update_layout(
+        title="Theorem 3.2 audit: realised deficit 1 − |⟨θ_∞,θ*⟩| vs e^(−M/2) + (d/n)^(1/5), d=512",
+        xaxis_title="e^(−M/2) + (d/n)^(1/5)", yaxis_title="1 − |⟨θ_∞, θ*⟩|",
+        xaxis_type="log", yaxis_type="log", template="plotly_white", height=470)
+    write_fig(fig, "audit_thm32")
+    out["thm32_max_C_Mge4"] = float(th[th["M"] >= 4]["C_implied"].max())
+    out["thm32_max_C_all"] = float(th["C_implied"].max())
+
+    # --- smooth vs hard truncation robustness ---------------------------------
+    p = f"{RES}/sweep_smooth.csv"
+    if os.path.exists(p):
+        sm = pd.read_csv(p).groupby(["d", "delta"])["sq_overlap"].mean().reset_index()
+        hd = pd.read_csv(f"{RES}/sweep_trunc.csv").groupby(["d", "delta"])["sq_overlap"] \
+            .mean().reset_index()
+        dims2 = sorted(sm["d"].unique())
+        fig = go.Figure()
+        for i, d in enumerate(dims2):
+            s = sm[sm["d"] == d].sort_values("delta")
+            h = hd[hd["d"] == d].sort_values("delta")
+            fig.add_trace(go.Scatter(x=s["delta"], y=s["sq_overlap"], mode="lines+markers",
+                                     name=f"smooth d={d}", line=dict(color=_c(i, len(dims2)))))
+            fig.add_trace(go.Scatter(x=h["delta"], y=h["sq_overlap"], mode="lines",
+                                     name=f"hard d={d}",
+                                     line=dict(color=_c(i, len(dims2)), dash="dot")))
+        fig.update_layout(
+            title="Robustness: C^∞ truncation (eq. 3.10, solid) vs hard truncation (eq. 4.3, dotted)",
+            xaxis_title="δ = n/d", yaxis_title="squared overlap",
+            template="plotly_white", height=470)
+        write_fig(fig, "audit_smooth_vs_hard")
+        mrg = sm.merge(hd, on=["d", "delta"], suffixes=("_smooth", "_hard"))
+        mrg["absdiff"] = (mrg["sq_overlap_smooth"] - mrg["sq_overlap_hard"]).abs()
+        mrg.to_csv(f"{RES}/smooth_vs_hard.csv", index=False)
+        out["smooth_vs_hard_maxdiff_delta_ge_4"] = float(mrg[mrg["delta"] >= 4]["absdiff"].max())
+        out["smooth_vs_hard_meandiff_delta_ge_4"] = float(mrg[mrg["delta"] >= 4]["absdiff"].mean())
+
+    with open(f"{RES}/audit_summary.json", "w") as f:
+        json.dump(out, f, indent=2, default=float)
+    print(json.dumps(out, indent=2, default=float))
+
+
+if __name__ == "__main__":
+    main()

scripts/analyze_gd.py

@@ -0,0 +1,236 @@
+"""Analysis + figures for the squared-loss GD trajectories (Claims 3 and 4).
+
+Theorem 4.1:  ||theta_t - theta*||^2 <= C (1 - eta alpha)^{t - tbar},  tbar <= C log d / eta.
+Section 4:    phase 1 = angle reduction + norm growth (O(log d / eta) steps),
+              phase 2 = geometric refinement.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import math
+import os
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+
+from analyze import PALETTE, _c, linfit, write_fig, thresholds_fig
+
+RES = "results"
+
+
+def load(prefix):
+    t = pd.read_csv(f"{RES}/{prefix}_traj.csv")
+    s = pd.read_csv(f"{RES}/{prefix}_summary.csv")
+    return t, s
+
+
+def mean_traj(t):
+    return (t.groupby(["d", "step"])[["sq_overlap", "norm", "dist2", "loss"]]
+             .mean().reset_index())
+
+
+def first_cross(steps, vals, target, above=True):
+    steps, vals = np.asarray(steps), np.asarray(vals)
+    m = vals >= target if above else vals <= target
+    return float(steps[np.argmax(m)]) if m.any() else np.nan
+
+
+def traj_fig(mt, ycol, title, ytitle, logy=False, hline=None):
+    dims = sorted(mt["d"].unique())
+    fig = go.Figure()
+    for i, d in enumerate(dims):
+        s = mt[mt["d"] == d]
+        fig.add_trace(go.Scatter(x=s["step"], y=s[ycol], mode="lines", name=f"d={d}",
+                                 line=dict(color=_c(i, len(dims)), width=2)))
+    if hline is not None:
+        fig.add_hline(y=hline, line_dash="dot", line_color="#888")
+    fig.update_layout(title=title, xaxis_title="GD step t", yaxis_title=ytitle,
+                      template="plotly_white", height=460)
+    if logy:
+        fig.update_yaxes(type="log")
+    return fig
+
+
+def phase_table(t, eta, targets=(0.9,)):
+    rows = []
+    for (d, seed), g in t.groupby(["d", "seed"]):
+        g = g.sort_values("step")
+        st, ov, nr, d2 = (g["step"].values, g["sq_overlap"].values,
+                          g["norm"].values, g["dist2"].values)
+        t_angle = first_cross(st, ov, 0.9)
+        t_norm = first_cross(st, nr, 0.25)
+        tbar = np.nanmax([t_angle, t_norm])
+        rate = np.nan
+        if np.isfinite(tbar):
+            m = (st >= tbar) & (d2 > 1e-11) & (d2 < 1e2)
+            if m.sum() >= 5:
+                b, a = np.polyfit(st[m], np.log(d2[m]), 1)
+                rate = float(b)
+        rows.append(dict(d=int(d), seed=int(seed), t_angle=t_angle, t_norm=t_norm,
+                         tbar=tbar, log_rate_per_step=rate,
+                         rho=math.exp(rate) if np.isfinite(rate) else np.nan,
+                         alpha_implied=(1 - math.exp(rate)) / eta
+                         if np.isfinite(rate) else np.nan,
+                         t_star_angle_pred=3 * math.log(d) / math.log(1 + 1.99 * eta)))
+    return pd.DataFrame(rows)
+
+
+def main():
+    out = {}
+    targets = [0.1, 0.2, 0.3, 0.4, 0.5]
+
+    # ------------------------------------------------ main run: r0 = d^-2 ----
+    t, s = load("gd_trunc_r2")
+    eta = float(s["eta"].iloc[0])
+    mt = mean_traj(t)
+    mt.to_csv(f"{RES}/agg_gd_trunc_r2.csv", index=False)
+    write_fig(traj_fig(mt, "sq_overlap",
+                       "Squared-loss full-batch GD — overlap vs steps (truncated σ, M=8, δ=10)",
+                       "Squared overlap ⟨θ*, θ̂⟩²"), "gd_overlap")
+    write_fig(traj_fig(mt, "norm",
+                       "Squared-loss full-batch GD — ‖θ_t‖ vs steps (truncated σ, M=8, δ=10)",
+                       "‖θ_t‖", hline=1.0), "gd_norm")
+    write_fig(traj_fig(mt, "dist2",
+                       "Strong recovery: ‖θ_t − θ*‖² vs steps (truncated σ, M=8, δ=10)",
+                       "‖θ_t − θ*‖²", logy=True), "gd_dist2")
+
+    thr = []
+    for d in sorted(mt["d"].unique()):
+        g = mt[mt["d"] == d].sort_values("step")
+        for tg in targets:
+            thr.append(dict(target=tg, d=int(d), logd=math.log(d),
+                            value=first_cross(g["step"], g["sq_overlap"], tg)))
+    tdf = pd.DataFrame(thr)
+    tdf.to_csv(f"{RES}/gd_time_thresholds.csv", index=False)
+    write_fig(thresholds_fig(thr, "Iteration complexity vs log d — full-batch GD, squared loss",
+                             ytitle="GD steps T to reach target overlap"), "gd_T_vs_logd")
+    out["T_vs_logd_fits"] = [
+        dict(target=tg, **linfit(tdf[tdf["target"] == tg]["logd"],
+                                 tdf[tdf["target"] == tg]["value"]))
+        for tg in targets]
+
+    ph = phase_table(t, eta)
+    ph.to_csv(f"{RES}/gd_phases.csv", index=False)
+    phm = ph.groupby("d").median(numeric_only=True).reset_index()
+    phm["logd"] = np.log(phm["d"])
+    out["eta"] = eta
+    out["phases_median"] = phm.to_dict("records")
+    out["tbar_vs_logd"] = linfit(phm["logd"], phm["tbar"])
+    out["alpha_implied"] = dict(median=float(phm["alpha_implied"].median()),
+                                min=float(phm["alpha_implied"].min()),
+                                max=float(phm["alpha_implied"].max()))
+    out["final"] = s.groupby("d")[["final_dist2", "final_sq_overlap", "final_norm",
+                                   "final_loss"]].median().reset_index().to_dict("records")
+
+    # phase figure: two-phase decomposition for one dimension
+    dsel = 1024 if 1024 in set(mt["d"]) else sorted(mt["d"])[-1]
+    g = mt[mt["d"] == dsel].sort_values("step")
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=g["step"], y=g["norm"], name="‖θ_t‖",
+                             line=dict(color=PALETTE[1], width=2)))
+    fig.add_trace(go.Scatter(x=g["step"], y=g["sq_overlap"], name="⟨θ*, θ̂⟩²",
+                             line=dict(color=PALETTE[5], width=2)))
+    fig.add_trace(go.Scatter(x=g["step"], y=g["dist2"], name="‖θ_t − θ*‖²",
+                             line=dict(color=PALETTE[3], width=2, dash="dot"),
+                             yaxis="y2"))
+    tb = float(phm[phm["d"] == dsel]["tbar"].iloc[0])
+    fig.add_vline(x=tb, line_dash="dash", line_color="#444",
+                  annotation_text=f"t̄ ≈ {tb:.0f}", annotation_position="top")
+    fig.update_layout(
+        title=f"Two-phase trajectory (d={dsel}): angle reduction + norm growth, then geometric refinement",
+        xaxis_title="GD step t", yaxis_title="overlap² / ‖θ_t‖",
+        yaxis2=dict(title="‖θ_t − θ*‖²", overlaying="y", side="right", type="log"),
+        template="plotly_white", height=470)
+    write_fig(fig, "gd_two_phase")
+
+    # ------------------------------------------------ r0 = d^-15 (Theorem) --
+    if os.path.exists(f"{RES}/gd_trunc_r15_traj.csv"):
+        t15, s15 = load("gd_trunc_r15")
+        mt15 = mean_traj(t15)
+        mt15.to_csv(f"{RES}/agg_gd_trunc_r15.csv", index=False)
+        write_fig(traj_fig(mt15, "norm",
+                           "Theorem 4.1 initialisation r₀ = d⁻¹⁵ — norm growth",
+                           "‖θ_t‖", logy=True), "gd_norm_r15")
+        thr15 = []
+        for d in sorted(mt15["d"].unique()):
+            g = mt15[mt15["d"] == d].sort_values("step")
+            for tg in targets:
+                thr15.append(dict(target=tg, d=int(d), logd=math.log(d),
+                                  value=first_cross(g["step"], g["sq_overlap"], tg)))
+        write_fig(thresholds_fig(thr15, "Iteration complexity vs log d — r₀ = d⁻¹⁵",
+                                 ytitle="GD steps T to reach target overlap"),
+                  "gd_T_vs_logd_r15")
+        pd.DataFrame(thr15).to_csv(f"{RES}/gd_time_thresholds_r15.csv", index=False)
+        out["r15_T_vs_logd_fits"] = [
+            dict(target=tg, **linfit([r["logd"] for r in thr15 if r["target"] == tg],
+                                     [r["value"] for r in thr15 if r["target"] == tg]))
+            for tg in targets]
+        ph15 = phase_table(t15, float(s15["eta"].iloc[0]))
+        ph15.to_csv(f"{RES}/gd_phases_r15.csv", index=False)
+        out["r15_phases_median"] = (ph15.groupby("d").median(numeric_only=True)
+                                    .reset_index().to_dict("records"))
+        out["r15_final"] = s15.groupby("d")[["final_dist2", "final_sq_overlap"]] \
+            .median().reset_index().to_dict("records")
+
+    # ------------------------------------------------ eta scaling (Claim 4) --
+    eta_rows = []
+    for path in sorted(glob.glob(f"{RES}/gd_trunc_eta*_summary.csv")) + \
+            [f"{RES}/gd_trunc_r2_summary.csv"]:
+        pre = path.replace("_summary.csv", "").split("/")[-1]
+        tt, ss = load(pre)
+        e = float(ss["eta"].iloc[0])
+        p = phase_table(tt, e).groupby("d").median(numeric_only=True).reset_index()
+        for r in p.itertuples():
+            eta_rows.append(dict(eta=e, d=int(r.d), tbar=r.tbar,
+                                 tbar_times_eta=r.tbar * e,
+                                 alpha_implied=r.alpha_implied))
+    if eta_rows:
+        edf = pd.DataFrame(eta_rows)
+        edf.to_csv(f"{RES}/gd_eta_scaling.csv", index=False)
+        fig = go.Figure()
+        for i, d in enumerate(sorted(edf["d"].unique())):
+            s2 = edf[edf["d"] == d].sort_values("eta")
+            fig.add_trace(go.Scatter(x=1 / s2["eta"], y=s2["tbar"], mode="lines+markers",
+                                     name=f"d={d}", line=dict(color=_c(i, edf["d"].nunique()))))
+        fig.update_layout(title="Phase-1 length t̄ scales as 1/η (fixed d, δ=10)",
+                          xaxis_title="1/η", yaxis_title="t̄ (steps)",
+                          template="plotly_white", height=440)
+        write_fig(fig, "gd_tbar_vs_eta")
+        out["eta_scaling"] = edf.to_dict("records")
+
+    # ------------------------------------------------ control: quadratic ----
+    if os.path.exists(f"{RES}/gd_quad_r2_summary.csv"):
+        _, sq = load("gd_quad_r2")
+        out["control_quad_final"] = (sq.groupby("d")[["final_dist2", "final_sq_overlap",
+                                                      "final_norm", "final_loss"]]
+                                     .median().reset_index().to_dict("records"))
+        cmp_rows = []
+        for act, dfx in (("trunc", s), ("quad", sq)):
+            for r in (dfx.groupby("d")[["final_dist2"]].median().reset_index()).itertuples():
+                cmp_rows.append(dict(act=act, d=int(r.d), final_dist2=float(r.final_dist2)))
+        cdf = pd.DataFrame(cmp_rows)
+        fig = go.Figure()
+        for i, act in enumerate(["trunc", "quad"]):
+            s2 = cdf[cdf["act"] == act].sort_values("d")
+            fig.add_trace(go.Bar(x=[str(int(v)) for v in s2["d"]], y=s2["final_dist2"],
+                                 name={"trunc": "truncated σ (Thm 4.1)",
+                                       "quad": "untruncated σ(z)=z² (control)"}[act],
+                                 marker_color=PALETTE[1 if act == "trunc" else 5]))
+        fig.update_layout(title="Strong recovery control: final ‖θ_T − θ*‖² at δ=10, T=6000",
+                          xaxis_title="d", yaxis_title="‖θ_T − θ*‖²", yaxis_type="log",
+                          template="plotly_white", height=440, barmode="group")
+        write_fig(fig, "gd_control_quad")
+        cdf.to_csv(f"{RES}/gd_control_quad.csv", index=False)
+
+    with open(f"{RES}/gd_analysis_summary.json", "w") as f:
+        json.dump(out, f, indent=2, default=float)
+    print(json.dumps({k: v for k, v in out.items()
+                      if k in ("eta", "T_vs_logd_fits", "tbar_vs_logd", "alpha_implied",
+                               "phases_median", "final")}, indent=2, default=float))
+
+
+if __name__ == "__main__":
+    main()

scripts/make_poster_figs.py

@@ -0,0 +1,229 @@
+"""Render poster PNGs (3200x2000, aspect 1.6) from the reproduction CSVs."""
+
+from __future__ import annotations
+
+import math
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+from analyze import linfit
+
+RES, OUT = "results", "images"
+os.makedirs(OUT, exist_ok=True)
+
+ACC = "#1f4e79"
+ACC2 = "#c2410c"
+GOLD = "#b45309"
+GREY = "#6b7280"
+CMAP = plt.get_cmap("plasma")
+
+plt.rcParams.update({
+    "font.size": 26, "axes.labelsize": 30, "axes.titlesize": 32,
+    "legend.fontsize": 24, "xtick.labelsize": 25, "ytick.labelsize": 25,
+    "axes.linewidth": 2.2, "lines.linewidth": 4.0, "grid.alpha": 0.28,
+    "figure.dpi": 200, "savefig.bbox": "tight", "savefig.pad_inches": 0.25,
+})
+FS = (16, 10)
+FS_WIDE = (17.6, 8.0)
+
+
+def _dcolors(dims):
+    return {d: CMAP(0.06 + 0.82 * i / max(len(dims) - 1, 1)) for i, d in enumerate(dims)}
+
+
+def fig_overlap(act, title, fname, annotate=None):
+    a = pd.read_csv(f"{RES}/agg_{act}.csv")
+    dims = sorted(a["d"].unique())
+    cols = _dcolors(dims)
+    fig, ax = plt.subplots(figsize=FS)
+    for d in dims:
+        s = a[a["d"] == d].sort_values("delta")
+        ax.plot(s["delta"], s["mean"], "-o", ms=8, color=cols[d], label=f"d={d}")
+    ax.set_xlabel(r"$\delta = n/d$")
+    ax.set_ylabel(r"squared overlap $\langle\theta^\star,\hat\theta\rangle^2$")
+    ax.set_title(title, pad=14)
+    ax.grid(True, ls=":")
+    ax.legend(ncol=2, frameon=False, loc="lower right")
+    if annotate:
+        ax.annotate(annotate, xy=(0.03, 0.95), xycoords="axes fraction", va="top",
+                    fontsize=26, color=ACC2, weight="bold")
+    fig.savefig(f"{OUT}/{fname}", dpi=200)
+    plt.close(fig)
+
+
+def fig_separation():
+    t = pd.read_csv(f"{RES}/thresholds.csv")
+    fig, ax = plt.subplots(figsize=(16, 10.6))
+    combos = [("one-pass-sgd", "trunc", "one-pass SGD, truncated", ACC2, "o"),
+              ("full-batch", "quad", "full-batch GD, quadratic", GOLD, "s"),
+              ("full-batch", "trunc", "full-batch GD, truncated", ACC, "D")]
+    for meth, act, lab, col, mk in combos:
+        s = t[(t["method"] == meth) & (t["act"] == act) & (t["target"] == 0.3)].sort_values("logd")
+        s = s[np.isfinite(s["value"])]
+        f = linfit(s["logd"], s["value"])
+        ax.plot(s["logd"], s["value"], mk, ms=16, color=col,
+                label=f"{lab} — slope {f['slope']:.2f}")
+        xs = np.linspace(s["logd"].min(), s["logd"].max(), 10)
+        ax.plot(xs, f["intercept"] + f["slope"] * xs, "-", color=col, lw=3.5, alpha=0.8)
+    ax.set_xlabel(r"$\log d$")
+    ax.set_ylabel(r"threshold $\delta = n/d$ for overlap$^2 = 0.3$")
+    ax.set_title("Sample complexity: full-batch removes the $\\log d$ factor", pad=14)
+    ax.grid(True, ls=":")
+    ax.legend(frameon=False, loc="upper left")
+    fig.savefig(f"{OUT}/pf_separation.png", dpi=200)
+    plt.close(fig)
+
+
+def fig_strong():
+    a = pd.read_csv(f"{RES}/agg_gd_trunc_r2.csv")
+    dims = sorted(a["d"].unique())
+    cols = _dcolors(dims)
+    fig, ax = plt.subplots(figsize=FS_WIDE)
+    for d in dims:
+        s = a[a["d"] == d].sort_values("step")
+        ax.semilogy(s["step"], np.maximum(s["dist2"], 1e-13), color=cols[d], label=f"d={d}")
+    ax.set_xlabel("GD step $t$")
+    ax.set_ylabel(r"$\|\theta_t-\theta^\star\|^2$")
+    ax.set_title(r"Strong recovery: geometric convergence after the search phase", pad=14)
+    ax.grid(True, ls=":", which="both")
+    ax.legend(ncol=2, frameon=False, loc="upper right")
+    fig.savefig(f"{OUT}/pf_strong.png", dpi=200)
+    plt.close(fig)
+
+
+def fig_two_phase():
+    a = pd.read_csv(f"{RES}/agg_gd_trunc_r2.csv")
+    ph = pd.read_csv(f"{RES}/gd_phases.csv").groupby("d").median(numeric_only=True)
+    d = 1024 if 1024 in set(a["d"]) else sorted(a["d"])[-1]
+    s = a[a["d"] == d].sort_values("step")
+    tb = float(ph.loc[d, "tbar"])
+    fig, ax = plt.subplots(figsize=FS_WIDE)
+    ax.plot(s["step"], s["norm"], color=ACC, label=r"$\|\theta_t\|$")
+    ax.plot(s["step"], s["sq_overlap"], color=ACC2, label=r"overlap$^2$")
+    ax.axvline(tb, color="#374151", ls="--", lw=3)
+    ax.axvspan(0, tb, color=GOLD, alpha=0.09)
+    ax.text(tb * 0.5, 0.55, "Phase 1\nangle ↓, norm ↑", ha="center", fontsize=26, color=GOLD)
+    ax.text(tb * 1.35, 0.30, "Phase 2\ngeometric", ha="left", fontsize=26, color=ACC)
+    ax2 = ax.twinx()
+    ax2.semilogy(s["step"], np.maximum(s["dist2"], 1e-13), color=GREY, ls=":", lw=3.5,
+                 label=r"$\|\theta_t-\theta^\star\|^2$")
+    ax2.set_ylabel(r"$\|\theta_t-\theta^\star\|^2$", color=GREY)
+    ax.set_xlim(0, min(float(s["step"].max()), tb * 2.6))
+    ax.set_xlabel("GD step $t$")
+    ax.set_ylabel(r"$\|\theta_t\|$  /  overlap$^2$")
+    ax.set_title(f"Two-phase trajectory (d={d}, $\\bar t\\approx${tb:.0f})", pad=14)
+    ax.grid(True, ls=":")
+    ax.legend(frameon=False, loc="center right")
+    fig.savefig(f"{OUT}/pf_two_phase.png", dpi=200)
+    plt.close(fig)
+
+
+def fig_time():
+    t = pd.read_csv(f"{RES}/gd_time_thresholds.csv")
+    ph = pd.read_csv(f"{RES}/gd_phases.csv").groupby("d").median(numeric_only=True).reset_index()
+    fig, ax = plt.subplots(figsize=FS)
+    tg = sorted(t["target"].unique())
+    for i, g in enumerate(tg):
+        s = t[t["target"] == g].sort_values("logd")
+        f = linfit(s["logd"], s["value"])
+        c = CMAP(0.08 + 0.75 * i / max(len(tg) - 1, 1))
+        ax.plot(s["logd"], s["value"], "o", ms=14, color=c,
+                label=f"overlap$^2$={g} ($R^2$={f['r2']:.2f})")
+        xs = np.linspace(s["logd"].min(), s["logd"].max(), 10)
+        ax.plot(xs, f["intercept"] + f["slope"] * xs, "-", color=c, lw=3, alpha=0.85)
+    f = linfit(np.log(ph["d"]), ph["tbar"])
+    ax.plot(np.log(ph["d"]), ph["tbar"], "k^--", ms=15, lw=3,
+            label=f"$\\bar t$ (phase 1 end), $R^2$={f['r2']:.2f}")
+    ax.set_xlabel(r"$\log d$")
+    ax.set_ylabel("GD steps")
+    ax.set_title(r"Iteration complexity grows like $\log d$", pad=14)
+    ax.grid(True, ls=":")
+    ax.legend(frameon=False, loc="upper left", ncol=2)
+    fig.savefig(f"{OUT}/pf_time.png", dpi=200)
+    plt.close(fig)
+
+
+def fig_spectrum():
+    a = pd.read_csv(f"{RES}/audit_spectrum.csv")
+    fig, ax = plt.subplots(figsize=FS)
+    q = a[(a["act"] == "quad")].groupby(["d", "delta"])[["lam1", "lam2"]].mean().reset_index()
+    tr = a[(a["act"] == "trunc") & (a["M"] == 8.0)].groupby(["d", "delta"])[["lam1", "lam2"]] \
+          .mean().reset_index()
+    dims = sorted(set(q["d"]) & set(tr["d"]))
+    cols = _dcolors(dims)
+    for d in dims:
+        s = q[q["d"] == d].sort_values("delta")
+        ax.plot(s["delta"], s["lam1"], "--o", ms=9, color=cols[d], alpha=0.85)
+        s = tr[tr["d"] == d].sort_values("delta")
+        ax.plot(s["delta"], s["lam1"], "-D", ms=9, color=cols[d])
+    ax.axhline(6, color="#111", ls=":", lw=3)
+    ax.text(a["delta"].max() * 0.55, 6.4, r"population $\lambda_1=6$", fontsize=25)
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.set_xlabel(r"$\delta = n/d$")
+    ax.set_ylabel(r"$\lambda_1(A^\star)$")
+    ax.set_title(r"BBP spike survives only under truncation (solid) — quadratic (dashed) diverges",
+                 pad=14, fontsize=27)
+    ax.grid(True, ls=":", which="both")
+    hd = [plt.Line2D([], [], color="k", ls="-", marker="D", label="truncated $\\sigma$"),
+          plt.Line2D([], [], color="k", ls="--", marker="o", label="quadratic $\\sigma$")]
+    hd += [plt.Line2D([], [], color=cols[d], lw=5, label=f"d={d}") for d in dims]
+    ax.legend(handles=hd, frameon=False, ncol=2, loc="upper right")
+    fig.savefig(f"{OUT}/pf_spectrum.png", dpi=200)
+    plt.close(fig)
+
+
+def fig_scorecard():
+    rows = [
+        ("1", "Quadratic σ: no full-batch gain (Thm 3.1)", "SUPPORTED",
+         "δ* ∝ log d, slope 0.65–0.95, R² 0.97–0.99"),
+        ("2", "Truncated σ: weak recovery at n ≳ d (Thm 3.2)", "SUPPORTED",
+         "curves collapse: spread 0.020 vs 0.126"),
+        ("3", "Strong recovery, T ≳ log d (Thm 4.1)", "SUPPORTED",
+         "‖θ_T−θ*‖² → 1e-13 at r₀ = d⁻¹⁵"),
+        ("4", "Two-phase trajectory (Sec. 4)", "SUPPORTED",
+         "t̄ ∝ log d (R² 0.97) and ∝ 1/η; α ≈ 2.7"),
+        ("5", "Matches the n ≳ d lower bound (Thm 3.2)", "SUPPORTED",
+         "slope 0.04 vs 1.52 for one-pass SGD"),
+    ]
+    fig, ax = plt.subplots(figsize=FS)
+    ax.axis("off")
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    y = 0.90
+    ax.text(0.02, 0.985, "Verdict by claim", fontsize=34, weight="bold", color=ACC, va="top")
+    for num, name, verdict, ev in rows:
+        ax.add_patch(plt.Rectangle((0.015, y - 0.145), 0.97, 0.14, facecolor="#f6f7f9",
+                                   edgecolor="#d7dbe0", lw=2))
+        ax.add_patch(plt.Rectangle((0.015, y - 0.145), 0.012, 0.14, facecolor=ACC, lw=0))
+        ax.text(0.045, y - 0.035, f"Claim {num} · {name}", fontsize=27, weight="bold", va="top")
+        ax.text(0.045, y - 0.098, ev, fontsize=24, color="#334155", va="top")
+        ax.text(0.965, y - 0.062, verdict, fontsize=26, weight="bold", color="#166534",
+                ha="right", va="center")
+        y -= 0.165
+    ax.text(0.02, 0.055, "5/5 claims reproduced · 2× RTX 4000 Ada · ~5.6 GPU-hours · $0 cloud spend",
+            fontsize=25, color=GREY, va="center")
+    fig.savefig(f"{OUT}/pf_scorecard.png", dpi=200)
+    plt.close(fig)
+
+
+if __name__ == "__main__":
+    fig_overlap("quad", r"Quadratic $\sigma(z)=z^2$: threshold drifts right with $d$",
+                "pf_quad.png")
+    fig_overlap("trunc", r"Truncated $\sigma(z)=\min(z^2,8)$: curves collapse",
+                "pf_trunc.png")
+    fig_separation()
+    fig_strong()
+    fig_two_phase()
+    fig_time()
+    try:
+        fig_spectrum()
+    except FileNotFoundError:
+        print("skip spectrum (audit not finished)")
+    fig_scorecard()
+    print("wrote", sorted(os.listdir(OUT)))

scripts/sim.py

@@ -0,0 +1,299 @@
+"""Core simulation library for reproducing arXiv:2602.02431 (ICML 2026 #26332).
+
+Single-index model:  x_i ~ N(0, I_d),  y_i = sigma(<x_i, theta*>),  ||theta*|| = 1.
+
+Activations
+-----------
+* ``quad``          sigma(z) = z^2                      (paper Sec. 3.1)
+* ``trunc``         sigma(z) = min(z^2, M)              (paper eq. 4.3, hard truncation)
+* ``smooth``        sigma(z) = int_0^{z^2} phi(u) du    (paper eq. 3.10, smooth truncation)
+
+Algorithms
+----------
+* ``spherical_flow``  full-batch spherical GD on the correlation loss
+                      L(theta) = -(1/n) sum_i y_i sigma(<x_i, theta>)
+                      theta <- normalize(theta + eta (I - theta theta^T) A(theta) theta)
+                      with A(theta) = (2/n) sum_i y_i phi(<x_i,theta>^2) x_i x_i^T.
+* ``online_sgd``      one-pass spherical SGD on the same loss (each sample used once).
+* ``squared_gd``      full-batch Euclidean GD on the squared loss (paper Sec. 4).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import torch
+
+
+# --------------------------------------------------------------------------- #
+# activations
+# --------------------------------------------------------------------------- #
+def _bump(u: torch.Tensor) -> torch.Tensor:
+    """gamma(u) = exp(-1/u) for u > 0, else 0."""
+    out = torch.zeros_like(u)
+    pos = u > 0
+    out[pos] = torch.exp(-1.0 / u[pos])
+    return out
+
+
+def phi_smooth(u: torch.Tensor, M: float) -> torch.Tensor:
+    """C^inf cutoff: phi = 1 for |u| <= M, 0 for |u| >= 2M (paper Sec. 3.2)."""
+    t = (u.abs() - M) / M
+    g0, g1 = _bump(t), _bump(1.0 - t)
+    S = torch.where(g0 + g1 > 0, g0 / (g0 + g1 + 1e-300), torch.zeros_like(t))
+    return (1.0 - S).clamp_(0.0, 1.0)
+
+
+_SMOOTH_TABLE: dict[tuple[float, str, str], tuple[torch.Tensor, torch.Tensor]] = {}
+
+
+def _smooth_sigma_table(M: float, device, dtype, npts: int = 200_001):
+    key = (M, str(device), str(dtype))
+    if key not in _SMOOTH_TABLE:
+        u = torch.linspace(0.0, 2.0 * M, npts, device=device, dtype=dtype)
+        f = phi_smooth(u, M)
+        du = u[1] - u[0]
+        cum = torch.cumsum((f[1:] + f[:-1]) * 0.5 * du, dim=0)
+        cum = torch.cat([torch.zeros(1, device=device, dtype=dtype), cum])
+        _SMOOTH_TABLE[key] = (u, cum)
+    return _SMOOTH_TABLE[key]
+
+
+def sigma(z: torch.Tensor, act: str, M: float) -> torch.Tensor:
+    if act == "quad":
+        return z * z
+    if act == "trunc":
+        return torch.clamp(z * z, max=M)
+    if act == "smooth":
+        u, cum = _smooth_sigma_table(M, z.device, z.dtype)
+        w = torch.clamp(z * z, max=2.0 * M)
+        idx = torch.clamp(
+            torch.searchsorted(u, w.reshape(-1).contiguous()), 1, u.numel() - 1
+        )
+        u0, u1 = u[idx - 1], u[idx]
+        c0, c1 = cum[idx - 1], cum[idx]
+        frac = (w.reshape(-1) - u0) / (u1 - u0)
+        return (c0 + frac * (c1 - c0)).reshape(z.shape)
+    raise ValueError(act)
+
+
+def phi(w: torch.Tensor, act: str, M: float) -> torch.Tensor:
+    """phi(u) with sigma'(z) = 2 z phi(z^2); argument ``w`` is z^2."""
+    if act == "quad":
+        return torch.ones_like(w)
+    if act == "trunc":
+        return (w < M).to(w.dtype)
+    if act == "smooth":
+        return phi_smooth(w, M)
+    raise ValueError(act)
+
+
+def sigma_prime(z: torch.Tensor, act: str, M: float) -> torch.Tensor:
+    return 2.0 * z * phi(z * z, act, M)
+
+
+# --------------------------------------------------------------------------- #
+# data
+# --------------------------------------------------------------------------- #
+@dataclass
+class Data:
+    X: torch.Tensor
+    y: torch.Tensor
+    theta_star: torch.Tensor
+
+
+def make_data(d: int, n: int, seed: int, act: str, M: float, device, dtype) -> Data:
+    g = torch.Generator(device=device).manual_seed(seed)
+    theta_star = torch.randn(d, generator=g, device=device, dtype=dtype)
+    theta_star /= theta_star.norm()
+    X = torch.randn(n, d, generator=g, device=device, dtype=dtype)
+    y = sigma(X @ theta_star, act, M)
+    return Data(X, y, theta_star)
+
+
+def rand_sphere(d: int, seed: int, device, dtype) -> torch.Tensor:
+    g = torch.Generator(device=device).manual_seed(seed)
+    v = torch.randn(d, generator=g, device=device, dtype=dtype)
+    return v / v.norm()
+
+
+# --------------------------------------------------------------------------- #
+# full-batch spherical gradient descent on the correlation loss
+# --------------------------------------------------------------------------- #
+def a_star(data: Data) -> torch.Tensor:
+    """A* = (2/n) sum_i y_i x_i x_i^T  (paper eq. 3.3)."""
+    n = data.X.shape[0]
+    return (2.0 / n) * (data.X.T @ (data.y[:, None] * data.X))
+
+
+def _Atheta_matvec(data: Data, theta: torch.Tensor, act: str, M: float) -> torch.Tensor:
+    """A(theta) @ theta without forming A(theta)  (paper eq. 3.11)."""
+    z = data.X @ theta
+    w = data.y * phi(z * z, act, M) * z
+    return (2.0 / data.X.shape[0]) * (data.X.T @ w)
+
+
+def spherical_flow(
+    data: Data,
+    theta0: torch.Tensor,
+    act: str,
+    M: float,
+    eta: float = 0.1,
+    T: int = 1000,
+    tol: float = 1e-12,
+    check_every: int = 50,
+    use_matrix: bool | None = None,
+    record_every: int = 0,
+):
+    """Full-batch spherical GD on the correlation loss (paper eq. 3.4 / 3.12).
+
+    Returns ``(theta, steps_run, trace)`` where ``trace`` is a list of
+    ``(step, squared_overlap)`` when ``record_every > 0``.
+    """
+    if use_matrix is None:
+        use_matrix = act == "quad"
+    A = a_star(data) if use_matrix else None
+    theta = theta0.clone()
+    ts = data.theta_star
+    trace = []
+    prev_ray = None
+    prev_ov = None
+    steps = T
+    for t in range(T):
+        Ath = (A @ theta) if use_matrix else _Atheta_matvec(data, theta, act, M)
+        ray = theta @ Ath
+        grad = Ath - ray * theta                    # (I - theta theta^T) A(theta) theta
+        theta = theta + eta * grad
+        theta = theta / theta.norm()
+        if record_every and (t % record_every == 0 or t == T - 1):
+            trace.append((t + 1, float((theta @ ts) ** 2)))
+        if (t + 1) % check_every == 0:
+            # converged: Rayleigh quotient (= -loss) and overlap both stationary
+            ray, ov = float(ray), float((theta @ ts) ** 2)
+            if (
+                prev_ray is not None
+                and abs(ray - prev_ray) <= tol * max(abs(ray), 1e-30)
+                and abs(ov - prev_ov) <= tol
+            ):
+                steps = t + 1
+                break
+            prev_ray, prev_ov = ray, ov
+    return theta, steps, trace
+
+
+# --------------------------------------------------------------------------- #
+# one-pass (online) spherical SGD on the correlation loss
+# --------------------------------------------------------------------------- #
+def online_sgd(
+    d: int,
+    n: int,
+    seeds: int,
+    act: str,
+    M: float,
+    eta: float,
+    seed0: int,
+    device,
+    dtype,
+    checkpoints: list[int],
+    chunk: int = 2048,
+):
+    """One-pass spherical SGD, vectorised over ``seeds`` independent replicas.
+
+    theta <- normalize(theta + eta (I - theta theta^T) y_t sigma'(<x_t,theta>) x_t)
+
+    Returns dict ``{n_used: mean squared overlap}`` measured at ``checkpoints``.
+    """
+    g = torch.Generator(device=device).manual_seed(seed0)
+    ts = torch.randn(seeds, d, generator=g, device=device, dtype=dtype)
+    ts /= ts.norm(dim=1, keepdim=True)
+    th = torch.randn(seeds, d, generator=g, device=device, dtype=dtype)
+    th /= th.norm(dim=1, keepdim=True)
+
+    out: dict[int, float] = {}
+    cps = sorted(checkpoints)
+    ci = 0
+    done = 0
+    while done < n:
+        m = min(chunk, n - done)
+        Xc = torch.randn(seeds, m, d, generator=g, device=device, dtype=dtype)
+        for j in range(m):
+            x = Xc[:, j, :]                                   # (S, d)
+            zstar = (x * ts).sum(1)
+            y = sigma(zstar, act, M)
+            z = (x * th).sum(1)
+            coef = y * sigma_prime(z, act, M)                 # (S,)
+            gvec = coef[:, None] * x
+            gvec = gvec - (gvec * th).sum(1, keepdim=True) * th
+            th = th + eta * gvec
+            th = th / th.norm(dim=1, keepdim=True)
+            done += 1
+            while ci < len(cps) and done == cps[ci]:
+                out[done] = float(((th * ts).sum(1) ** 2).mean())
+                ci += 1
+        del Xc
+    return out
+
+
+# --------------------------------------------------------------------------- #
+# full-batch Euclidean GD on the squared loss (paper Sec. 4)
+# --------------------------------------------------------------------------- #
+def squared_gd(
+    data: Data,
+    theta0: torch.Tensor,
+    act: str,
+    M: float,
+    eta: float,
+    T: int,
+    record_every: int = 1,
+    stop_err: float | None = None,
+):
+    """theta_{t+1} = theta_t - eta * (1/n) sum_i (sigma(<x_i,th>) - y_i) sigma'(<x_i,th>) x_i.
+
+    Returns a dict of trajectory arrays (step, sq_overlap, norm, dist2, loss).
+    """
+    X, y, ts = data.X, data.y, data.theta_star
+    n = X.shape[0]
+    theta = theta0.clone()
+    rec = {"step": [], "sq_overlap": [], "norm": [], "dist2": [], "loss": []}
+
+    def _record(t):
+        nr = float(theta.norm())
+        ov = float((theta @ ts) ** 2) / max(nr * nr, 1e-300)
+        d2 = min(
+            float(((theta - ts) ** 2).sum()), float(((theta + ts) ** 2).sum())
+        )
+        z = X @ theta
+        loss = float((0.5 / n) * ((sigma(z, act, M) - y) ** 2).sum())
+        rec["step"].append(t)
+        rec["sq_overlap"].append(ov)
+        rec["norm"].append(nr)
+        rec["dist2"].append(d2)
+        rec["loss"].append(loss)
+        return d2
+
+    _record(0)
+    for t in range(1, T + 1):
+        z = X @ theta
+        resid = (sigma(z, act, M) - y) * sigma_prime(z, act, M)
+        grad = (X.T @ resid) / n
+        theta = theta - eta * grad
+        if record_every and (t % record_every == 0 or t == T):
+            d2 = _record(t)
+            if stop_err is not None and d2 < stop_err:
+                break
+    return rec
+
+
+# --------------------------------------------------------------------------- #
+# helpers
+# --------------------------------------------------------------------------- #
+def top2_eig(A: torch.Tensor):
+    """Top-two eigenvalues and top eigenvector of a symmetric matrix."""
+    A = 0.5 * (A + A.T)
+    evals, evecs = torch.linalg.eigh(A.double())
+    return float(evals[-1]), float(evals[-2]), evecs[:, -1].to(A.dtype)
+
+
+def log2_steps(d: int, mult: float = 1000.0) -> int:
+    return int(mult * math.log(d) ** 2)

scripts/smoke.py

@@ -0,0 +1,87 @@
+"""Smoke test + timing benchmark for sim.py."""
+import math
+import sys
+import time
+
+import torch
+
+sys.path.insert(0, __file__.rsplit("/", 1)[0])
+import sim
+
+dev = "cuda" if torch.cuda.is_available() else "cpu"
+print("device:", dev, torch.cuda.get_device_name(0) if dev == "cuda" else "")
+
+# --- activation sanity ------------------------------------------------------
+z = torch.linspace(-6, 6, 13, device=dev, dtype=torch.float64)
+for act in ("quad", "trunc", "smooth"):
+    s = sim.sigma(z, act, 8.0)
+    print(f"{act:7s} sigma:", [round(float(v), 3) for v in s])
+# numeric derivative check
+eps = 1e-6
+for act in ("quad", "trunc", "smooth"):
+    zz = torch.tensor([0.5, 1.5, 2.5, 3.5], device=dev, dtype=torch.float64)
+    num = (sim.sigma(zz + eps, act, 8.0) - sim.sigma(zz - eps, act, 8.0)) / (2 * eps)
+    ana = sim.sigma_prime(zz, act, 8.0)
+    print(f"{act:7s} d/dz max err:", float((num - ana).abs().max()))
+
+# --- E[2 y x x^T] spectrum sanity (population lambda1=6, lambda2=2 for quad) --
+for act in ("quad", "trunc", "smooth"):
+    d, n = 64, 64 * 400
+    data = sim.make_data(d, n, 0, act, 8.0, dev, torch.float64)
+    A = sim.a_star(data)
+    l1, l2, v1 = sim.top2_eig(A)
+    ov = float((v1 @ data.theta_star) ** 2)
+    print(f"{act:7s} n/d=400: lam1={l1:.3f} lam2={l2:.3f} ov^2={ov:.4f}")
+
+# --- flow smoke -------------------------------------------------------------
+for act in ("quad", "trunc"):
+    d, n = 256, 256 * 8
+    data = sim.make_data(d, n, 1, act, 8.0, dev, torch.float32)
+    th0 = sim.rand_sphere(d, 1234, dev, torch.float32)
+    t0 = time.time()
+    th, steps, _ = sim.spherical_flow(data, th0, act, 8.0, eta=0.1, T=20000)
+    ov = float((th @ data.theta_star) ** 2)
+    l1, l2, v1 = sim.top2_eig(sim.a_star(data))
+    print(
+        f"{act:7s} flow d={d} delta=8: ov^2={ov:.4f} steps={steps} "
+        f"({time.time()-t0:.1f}s)  v1(A*) ov^2={float((v1@data.theta_star)**2):.4f}"
+    )
+
+# --- squared-loss GD smoke --------------------------------------------------
+d, n = 256, 2560
+data = sim.make_data(d, n, 2, "trunc", 8.0, dev, torch.float64)
+th0 = sim.rand_sphere(d, 7, dev, torch.float64) * d ** -2.0
+t0 = time.time()
+rec = sim.squared_gd(data, th0, "trunc", 8.0, eta=0.1 / 64, T=4000, record_every=20)
+print(
+    f"squared GD d={d} delta=10: final ov^2={rec['sq_overlap'][-1]:.5f} "
+    f"norm={rec['norm'][-1]:.4f} dist2={rec['dist2'][-1]:.3e} ({time.time()-t0:.1f}s)"
+)
+
+# --- timing benchmark -------------------------------------------------------
+for d in (1024, 4096):
+    n = 11 * d
+    t0 = time.time()
+    data = sim.make_data(d, n, 3, "trunc", 8.0, dev, torch.float32)
+    torch.cuda.synchronize() if dev == "cuda" else None
+    t_gen = time.time() - t0
+    th0 = sim.rand_sphere(d, 5, dev, torch.float32)
+    t0 = time.time()
+    sim.spherical_flow(data, th0, "trunc", 8.0, T=200, check_every=10 ** 9)
+    torch.cuda.synchronize() if dev == "cuda" else None
+    t_flow = time.time() - t0
+    t0 = time.time()
+    A = sim.a_star(data)
+    torch.cuda.synchronize() if dev == "cuda" else None
+    t_A = time.time() - t0
+    t0 = time.time()
+    sim.spherical_flow(data, th0, "quad", 8.0, T=2000, check_every=10 ** 9)
+    torch.cuda.synchronize() if dev == "cuda" else None
+    t_mat = time.time() - t0
+    print(
+        f"d={d} n={n}: gen={t_gen:.2f}s  trunc-flow 200 steps={t_flow:.2f}s  "
+        f"form A*={t_A:.2f}s  matrix-flow 2000 steps={t_mat:.2f}s"
+    )
+    del data
+    torch.cuda.empty_cache() if dev == "cuda" else None
+print("T=1000 log^2 d:", {d: sim.log2_steps(d) for d in (64, 1024, 4096, 8192)})

scripts/spectral_audit.py

@@ -0,0 +1,141 @@
+"""Numerical audit of the spectral statements behind Theorems 3.1 and 3.2.
+
+(A) Spectrum of A* = (2/n) sum_i y_i x_i x_i^T.
+    Truncated sigma (paper eq. 3.13):  |lam1 - 6| + |lam2 - 2| <= C(e^{-M/3} + M sqrt(d/n)).
+    Quadratic sigma (proof of Thm 3.1): lam_max is driven by the heaviest sample,
+    lam1 ~ 2 log(n) / delta -> diverges with d at fixed delta, killing the BBP spike.
+
+(B) Uniform-in-theta BBP transition for A(theta) = (2/n) sum_i y_i phi(<x_i,theta>^2) x_i x_i^T,
+    the key technical ingredient of Theorem 3.2.
+
+(C) Uniform indicator-mass bound (Lemma "indicatorbound"):
+    (1/n) sum_i 1{<x_i,theta>^2 > M} <= C (e^{-M/2} + sqrt(d/n) log(n/d))  for all theta.
+    Checked on random directions and on adversarially chosen directions.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import os
+import sys
+import time
+
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import sim
+from sweep_spherical import a_star_chunked, top2
+
+
+def A_theta(data, theta, act, M):
+    z = data.X @ theta
+    w = data.y * sim.phi(z * z, act, M)
+    n = data.X.shape[0]
+    return (2.0 / n) * (data.X.T @ (w[:, None] * data.X))
+
+
+def adversarial_theta(data, M, iters=200, lr=0.5):
+    """Maximise the empirical mass of {<x_i,theta>^2 > M} by smoothed ascent."""
+    d = data.X.shape[1]
+    theta = data.X[data.y.argmax()].clone()
+    theta = theta / theta.norm()
+    theta.requires_grad_(True)
+    opt = torch.optim.Adam([theta], lr=lr)
+    tau = 0.5
+    for _ in range(iters):
+        opt.zero_grad()
+        z = data.X @ (theta / theta.norm())
+        loss = -torch.sigmoid((z * z - M) / tau).mean()
+        loss.backward()
+        opt.step()
+    with torch.no_grad():
+        theta = theta / theta.norm()
+    return theta.detach()
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--dims", default="128,256,512,1024,2048")
+    p.add_argument("--deltas", default="2,4,8,16,32,64,128")
+    p.add_argument("--Ms", default="2,4,8,16,32")
+    p.add_argument("--seeds", type=int, default=5)
+    p.add_argument("--n-theta", type=int, default=8, help="random thetas for part (B)")
+    p.add_argument("--out-prefix", required=True)
+    args = p.parse_args()
+
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    dims = [int(v) for v in args.dims.split(",")]
+    deltas = [float(v) for v in args.deltas.split(",")]
+    Ms = [float(v) for v in args.Ms.split(",")]
+    rows_a, rows_b, rows_c = [], [], []
+    t0 = time.time()
+
+    # ---- (A) spectrum of A* -------------------------------------------------
+    for act in ("quad", "trunc"):
+        for d in dims:
+            for delta in deltas:
+                n = int(round(delta * d))
+                for M in (Ms if act == "trunc" else [8.0]):
+                    for s in range(args.seeds):
+                        data = sim.make_data(d, n, 31 * d + 7 * s + int(delta), act, M,
+                                             dev, torch.float32)
+                        A = a_star_chunked(data.X, data.y).double()
+                        l1, l2, v1 = top2(A)
+                        ov = float((v1 @ data.theta_star.double()) ** 2)
+                        rows_a.append(dict(
+                            act=act, d=d, delta=delta, n=n, M=M, seed=s,
+                            lam1=round(l1, 6), lam2=round(l2, 6), gap=round(l1 - l2, 6),
+                            sq_overlap_v1=round(ov, 6), sin2=round(1 - ov, 8),
+                            logn_over_delta=round(2 * math.log(n) / delta, 4)))
+                        del data, A
+                    torch.cuda.empty_cache() if dev == "cuda" else None
+            print(f"[{time.time()-t0:6.1f}s] (A) {act} d={d} done", flush=True)
+
+    # ---- (B) uniform-in-theta BBP + (C) indicator mass ----------------------
+    g = torch.Generator(device=dev).manual_seed(11)
+    for act in ("quad", "trunc"):
+        for d in (256, 1024):
+            for delta in (4.0, 16.0, 64.0):
+                n = int(round(delta * d))
+                for M in ([8.0] if act == "quad" else [4.0, 8.0, 16.0]):
+                    data = sim.make_data(d, n, 77 * d + int(delta), act, M, dev, torch.float32)
+                    thetas = {}
+                    for k in range(args.n_theta):
+                        v = torch.randn(d, generator=g, device=dev, dtype=torch.float32)
+                        thetas[f"random{k}"] = v / v.norm()
+                    thetas["theta_star"] = data.theta_star
+                    thetas["adversarial"] = adversarial_theta(data, M)
+                    for name, th in thetas.items():
+                        A = A_theta(data, th, act, M).double()
+                        l1, l2, v1 = top2(A)
+                        ov = float((v1 @ data.theta_star.double()) ** 2)
+                        rows_b.append(dict(act=act, d=d, delta=delta, n=n, M=M,
+                                           theta=name, lam1=round(l1, 6),
+                                           lam2=round(l2, 6), gap=round(l1 - l2, 6),
+                                           sq_overlap_v1=round(ov, 6)))
+                        z = data.X @ th
+                        mass = float((z * z > M).to(torch.float64).mean())
+                        bound = math.exp(-M / 2) + math.sqrt(d / n) * math.log(n / d)
+                        rows_c.append(dict(act=act, d=d, delta=delta, n=n, M=M,
+                                           theta=name, mass=round(mass, 8),
+                                           bound_base=round(bound, 8),
+                                           ratio=round(mass / bound, 6)))
+                        del A
+                    del data
+                    torch.cuda.empty_cache() if dev == "cuda" else None
+            print(f"[{time.time()-t0:6.1f}s] (B/C) {act} d={d} done", flush=True)
+
+    for rows, name in ((rows_a, "spectrum"), (rows_b, "uniform_bbp"), (rows_c, "indicator")):
+        path = f"{args.out_prefix}_{name}.csv"
+        with open(path, "w", newline="") as f:
+            w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+            w.writeheader()
+            w.writerows(rows)
+        print("wrote", path, len(rows), "rows")
+
+
+if __name__ == "__main__":
+    main()

scripts/sweep_online_sgd.py

@@ -0,0 +1,72 @@
+"""One-pass (online) spherical SGD baseline on the correlation loss.
+
+Ben Arous et al. (2021), Thm 1.4: for information exponent 2 activations, one-pass
+SGD with the largest stable step size eta ~ 1/d needs n >~ d log d samples for weak
+recovery.  This is the baseline that Claims 2/5 of arXiv:2602.02431 separate from.
+
+Each replica sees every sample exactly once, so a single run of length n_max also
+gives the overlap for every smaller n -> the whole delta-curve comes from one pass.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+import os
+import sys
+import time
+
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import sim
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--act", default="trunc", choices=["quad", "trunc", "smooth"])
+    p.add_argument("--dims", default="64,128,256,512,1024,2048,4096,8192")
+    p.add_argument("--seeds", type=int, default=32)
+    p.add_argument("--M", type=float, default=8.0)
+    p.add_argument("--eta-cs", default="0.025,0.05,0.1,0.2",
+                   help="grid of step sizes eta = c/d (the c values)")
+    p.add_argument("--delta-max-mult", type=float, default=6.0,
+                   help="delta_max = mult * log(d)")
+    p.add_argument("--n-checkpoints", type=int, default=60)
+    p.add_argument("--out", required=True)
+    args = p.parse_args()
+
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    dims = [int(v) for v in args.dims.split(",")]
+    rows = []
+    t_start = time.time()
+    for d in dims:
+        dmax = args.delta_max_mult * math.log(d)
+        deltas = [round(dmax * (i + 1) / args.n_checkpoints, 4) for i in range(args.n_checkpoints)]
+        cps = sorted({max(1, int(round(dl * d))) for dl in deltas})
+        n_max = cps[-1]
+        chunk = max(128, min(2048, (1 << 23) // (d * args.seeds)))
+        for c in [float(v) for v in args.eta_cs.split(",")]:
+            eta = c / d
+            t0 = time.time()
+            out = sim.online_sgd(
+                d, n_max, args.seeds, args.act, args.M, eta, 4242 + d, dev,
+                torch.float32, cps, chunk=chunk,
+            )
+            for n_used, ov in out.items():
+                rows.append(dict(act=args.act, d=d, n=n_used, delta=round(n_used / d, 4),
+                                 eta_c=c, eta=eta, seeds=args.seeds,
+                                 sq_overlap=round(ov, 6)))
+            print(f"[{time.time()-t_start:7.1f}s] d={d:5d} n_max={n_max} eta={eta:.3g} "
+                  f"(c={c}) final ov2={out[cps[-1]]:.4f} ({time.time()-t0:.1f}s)", flush=True)
+
+    with open(args.out, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+        w.writeheader()
+        w.writerows(rows)
+    print(f"wrote {args.out} ({len(rows)} rows, {time.time()-t_start:.1f}s)")
+
+
+if __name__ == "__main__":
+    main()

scripts/sweep_spherical.py

@@ -0,0 +1,148 @@
+"""Full-batch spherical GD on the correlation loss: overlap vs delta = n/d.
+
+Reproduces Figures 1a/1b of arXiv:2602.02431 (paper #26332).
+  quad  -> Theorem 3.1 (Claim 1): threshold delta grows with log d
+  trunc -> Theorem 3.2 (Claims 2/5): threshold delta is d-independent
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+import os
+import sys
+import time
+
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import sim
+
+
+def a_star_chunked(X, y, chunk=16384):
+    n, d = X.shape
+    A = torch.zeros(d, d, device=X.device, dtype=X.dtype)
+    for i in range(0, n, chunk):
+        Xi = X[i : i + chunk]
+        A += Xi.T @ (y[i : i + chunk, None] * Xi)
+    return (2.0 / n) * A
+
+
+def top2(A):
+    """Top two eigenvalues + top eigenvector.
+
+    Full eigendecomposition is faster than LOBPCG below d ~ 3000 (LOBPCG is
+    kernel-launch bound at small d); above that we fall back to LOBPCG with k=2.
+    """
+    d = A.shape[0]
+    if d <= 3000:
+        ev, evec = torch.linalg.eigh(A.double())
+        return float(ev[-1]), float(ev[-2]), evec[:, -1]
+    try:
+        vals, vecs = torch.lobpcg(A.double(), k=2, largest=True, niter=400, tol=1e-10)
+        return float(vals[0]), float(vals[1]), vecs[:, 0]
+    except Exception:
+        ev, evec = torch.linalg.eigh(A.double())
+        return float(ev[-1]), float(ev[-2]), evec[:, -1]
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--act", default="trunc", choices=["quad", "trunc", "smooth"])
+    p.add_argument("--dims", default="64,128,256,512,1024,2048,4096")
+    p.add_argument("--delta-min", type=float, default=0.5)
+    p.add_argument("--delta-max", type=float, default=11.0)
+    p.add_argument("--delta-step", type=float, default=0.5)
+    p.add_argument("--seeds", default="32,32,32,16,16,8,8", help="per dim")
+    p.add_argument("--M", type=float, default=8.0)
+    p.add_argument("--eta", type=float, default=0.1)
+    p.add_argument("--T", type=int, default=3000, help="steps for non-quad activations")
+    p.add_argument("--spectrum", action="store_true", help="also record lam1/lam2/v1(A*)")
+    p.add_argument("--out", required=True)
+    args = p.parse_args()
+
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    dims = [int(v) for v in args.dims.split(",")]
+    seeds = [int(v) for v in args.seeds.split(",")]
+    assert len(seeds) == len(dims)
+    deltas = [
+        round(args.delta_min + i * args.delta_step, 4)
+        for i in range(int(round((args.delta_max - args.delta_min) / args.delta_step)) + 1)
+    ]
+    print(f"device={dev} act={args.act} dims={dims} seeds={seeds} deltas={deltas}", flush=True)
+
+    rows = []
+    t_start = time.time()
+    for d, ns in zip(dims, seeds):
+        # quadratic: A* is constant along the flow -> iterate on the d x d matrix (exact,
+        # and far cheaper); truncated: A(theta) is time-varying -> matrix-free matvecs.
+        use_matrix = args.act == "quad"
+        T = sim.log2_steps(d) if use_matrix else args.T
+        for delta in deltas:
+            n = int(round(delta * d))
+            for s in range(ns):
+                seed = 1000 * d + 7 * s + int(delta * 2)
+                t0 = time.time()
+                data = sim.make_data(d, n, seed, args.act, args.M, dev, torch.float32)
+                lam1 = lam2 = ov_v1 = float("nan")
+                if use_matrix or args.spectrum:
+                    A = a_star_chunked(data.X, data.y).double()
+                    lam1, lam2, v1 = top2(A)
+                    ov_v1 = float((v1 @ data.theta_star.double()) ** 2)
+                th0 = sim.rand_sphere(d, 500_000 + seed, dev, torch.float32)
+                if use_matrix:
+                    dd = sim.Data(data.X, data.y, data.theta_star.double())
+                    theta = th0.double()
+                    ts = dd.theta_star
+                    prev_r = prev_o = None
+                    steps = T
+                    for t in range(T):
+                        Ath = A @ theta
+                        ray = theta @ Ath
+                        grad = Ath - ray * theta
+                        theta = theta + args.eta * grad
+                        theta = theta / theta.norm()
+                        if (t + 1) % 200 == 0:
+                            r, o = float(ray), float((theta @ ts) ** 2)
+                            if (
+                                prev_r is not None
+                                and abs(r - prev_r) <= 1e-13 * abs(r)
+                                and abs(o - prev_o) <= 1e-13
+                            ):
+                                steps = t + 1
+                                break
+                            prev_r, prev_o = r, o
+                    ov = float((theta @ ts) ** 2)
+                else:
+                    theta, steps, _ = sim.spherical_flow(
+                        data, th0, args.act, args.M, eta=args.eta, T=T,
+                        tol=0.0, check_every=10 ** 9,
+                    )
+                    ov = float((theta @ data.theta_star) ** 2)
+                rows.append(
+                    dict(act=args.act, d=d, delta=delta, n=n, seed=seed, M=args.M,
+                         eta=args.eta, T=T, steps=steps, sq_overlap=round(ov, 6),
+                         lam1=lam1, lam2=lam2, sq_overlap_v1Astar=ov_v1,
+                         secs=round(time.time() - t0, 3))
+                )
+                del data
+                if use_matrix or args.spectrum:
+                    del A
+            torch.cuda.empty_cache() if dev == "cuda" else None
+            m = [r["sq_overlap"] for r in rows if r["d"] == d and r["delta"] == delta]
+            print(
+                f"[{time.time()-t_start:7.1f}s] d={d:5d} delta={delta:5.1f} "
+                f"mean ov2={sum(m)/len(m):.4f}  (n={n}, {ns} seeds)",
+                flush=True,
+            )
+
+    with open(args.out, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+        w.writeheader()
+        w.writerows(rows)
+    print(f"wrote {args.out} ({len(rows)} rows, {time.time()-t_start:.1f}s)")
+
+
+if __name__ == "__main__":
+    main()

scripts/sweep_squared_gd.py

@@ -0,0 +1,97 @@
+"""Full-batch Euclidean GD on the squared loss from small initialisation.
+
+Reproduces Figures 2a/2b/2c of arXiv:2602.02431 and audits Theorem 4.1 (Claim 3)
+and the two-phase trajectory decomposition of Section 4 (Claim 4).
+
+    sigma(z) = min(z^2, M),  M = 8,  eta = 0.1 / M^2,  delta = n/d = 10,
+    theta_0 ~ Unif(r0 * S^{d-1}),  r0 in {d^-2 (paper figures), d^-15 (Theorem 4.1)}.
+
+All runs are float64 so that r0 = d^-15 (down to ~1e-54) does not underflow.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import os
+import sys
+import time
+
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import sim
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--act", default="trunc", choices=["quad", "trunc", "smooth"])
+    p.add_argument("--dims", default="64,128,256,512,1024,2048,4096")
+    p.add_argument("--seeds", default="8", help="int, or one value per dim")
+    p.add_argument("--M", type=float, default=8.0)
+    p.add_argument("--delta", type=float, default=10.0)
+    p.add_argument("--eta-c", type=float, default=0.1, help="eta = c / M^2")
+    p.add_argument("--r0-exp", type=float, default=2.0, help="r0 = d^-exp")
+    p.add_argument("--T", type=int, default=6000)
+    p.add_argument("--record-every", type=int, default=5)
+    p.add_argument("--stop-err", type=float, default=1e-13)
+    p.add_argument("--out-prefix", required=True)
+    args = p.parse_args()
+
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    dims = [int(v) for v in args.dims.split(",")]
+    seed_list = [int(v) for v in args.seeds.split(",")]
+    if len(seed_list) == 1:
+        seed_list = seed_list * len(dims)
+    assert len(seed_list) == len(dims)
+    eta = args.eta_c / (args.M ** 2)
+    traj_rows, summ_rows = [], []
+    t_start = time.time()
+    for d, nseeds in zip(dims, seed_list):
+        n = int(round(args.delta * d))
+        r0 = float(d) ** (-args.r0_exp)
+        for s in range(nseeds):
+            seed = 90000 + 137 * d + s
+            t0 = time.time()
+            data = sim.make_data(d, n, seed, args.act, args.M, dev, torch.float64)
+            th0 = sim.rand_sphere(d, 800_000 + seed, dev, torch.float64) * r0
+            rec = sim.squared_gd(
+                data, th0, args.act, args.M, eta, args.T,
+                record_every=args.record_every, stop_err=args.stop_err,
+            )
+            for i in range(len(rec["step"])):
+                traj_rows.append(dict(
+                    act=args.act, d=d, delta=args.delta, M=args.M, eta=eta,
+                    r0_exp=args.r0_exp, seed=seed, step=rec["step"][i],
+                    sq_overlap=rec["sq_overlap"][i], norm=rec["norm"][i],
+                    dist2=rec["dist2"][i], loss=rec["loss"][i]))
+            summ_rows.append(dict(
+                act=args.act, d=d, n=n, delta=args.delta, M=args.M, eta=eta,
+                r0_exp=args.r0_exp, r0=r0, seed=seed,
+                steps_run=rec["step"][-1], final_sq_overlap=rec["sq_overlap"][-1],
+                final_norm=rec["norm"][-1], final_dist2=rec["dist2"][-1],
+                final_loss=rec["loss"][-1], secs=round(time.time() - t0, 2)))
+            del data
+            torch.cuda.empty_cache() if dev == "cuda" else None
+        fin = [r["final_dist2"] for r in summ_rows if r["d"] == d]
+        stp = [r["steps_run"] for r in summ_rows if r["d"] == d]
+        print(f"[{time.time()-t_start:7.1f}s] d={d:5d} n={n} r0={r0:.3e} "
+              f"median dist2={sorted(fin)[len(fin)//2]:.3e} median steps={sorted(stp)[len(stp)//2]}",
+              flush=True)
+
+    with open(args.out_prefix + "_traj.csv", "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=list(traj_rows[0].keys()))
+        w.writeheader()
+        w.writerows(traj_rows)
+    with open(args.out_prefix + "_summary.csv", "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=list(summ_rows[0].keys()))
+        w.writeheader()
+        w.writerows(summ_rows)
+    print(f"wrote {args.out_prefix}_{{traj,summary}}.csv "
+          f"({len(traj_rows)} traj rows, {time.time()-t_start:.1f}s)")
+
+
+if __name__ == "__main__":
+    main()

scripts/thm32_bound.py

@@ -0,0 +1,75 @@
+"""Quantitative audit of the Theorem 3.2 guarantee (Claim 2).
+
+    lim_t |<theta(t), theta*>| >= 1 - C (e^{-M/2} + (d/n)^{1/5}),   n >= C M^4 d.
+
+We run the full-batch spherical flow with the truncated activation on a grid of
+(M, delta = n/d) at fixed d, and report the realised deficit 1 - |<theta_inf, theta*>|
+against the theorem's rate  e^{-M/2} + (d/n)^{1/5}.  A single constant C should
+dominate the whole grid inside the theorem's regime delta >= C M^4.
+Also includes the M -> small control, where the guarantee degrades as predicted.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import math
+import os
+import sys
+import time
+
+import torch
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import sim
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--d", type=int, default=512)
+    p.add_argument("--Ms", default="1,2,4,8,16,32")
+    p.add_argument("--deltas", default="8,16,32,64,128,256")
+    p.add_argument("--seeds", type=int, default=8)
+    p.add_argument("--act", default="trunc", choices=["trunc", "smooth", "quad"])
+    p.add_argument("--eta", type=float, default=0.1)
+    p.add_argument("--T", type=int, default=3000)
+    p.add_argument("--out", required=True)
+    args = p.parse_args()
+
+    dev = "cuda" if torch.cuda.is_available() else "cpu"
+    Ms = [float(v) for v in args.Ms.split(",")]
+    deltas = [float(v) for v in args.deltas.split(",")]
+    d = args.d
+    rows = []
+    t0 = time.time()
+    for M in Ms:
+        for delta in deltas:
+            n = int(round(delta * d))
+            for s in range(args.seeds):
+                seed = 5000 + 31 * s + int(delta) + int(100 * M)
+                data = sim.make_data(d, n, seed, args.act, M, dev, torch.float32)
+                th0 = sim.rand_sphere(d, 600_000 + seed, dev, torch.float32)
+                th, steps, _ = sim.spherical_flow(data, th0, args.act, M, eta=args.eta,
+                                                  T=args.T, tol=0.0, check_every=10 ** 9)
+                ov = abs(float(th @ data.theta_star))
+                rate = math.exp(-M / 2) + (d / n) ** 0.2
+                rows.append(dict(act=args.act, d=d, M=M, delta=delta, n=n, seed=seed,
+                                 abs_overlap=round(ov, 6), deficit=round(1 - ov, 6),
+                                 rate=round(rate, 6),
+                                 C_implied=round((1 - ov) / rate, 6),
+                                 in_regime=int(delta >= M ** 4 / 100)))
+                del data
+            torch.cuda.empty_cache() if dev == "cuda" else None
+            sub = [r["deficit"] for r in rows if r["M"] == M and r["delta"] == delta]
+            print(f"[{time.time()-t0:6.1f}s] M={M:5.1f} delta={delta:6.1f} "
+                  f"mean deficit={sum(sub)/len(sub):.4f}", flush=True)
+
+    with open(args.out, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+        w.writeheader()
+        w.writerows(rows)
+    print("wrote", args.out, len(rows), "rows")
+
+
+if __name__ == "__main__":
+    main()