scripts/derivation_checks.py

#!/usr/bin/env python3
"""Numerical audits for DERIVATIONS.md CHK-D1..D6c (kcnuX4xEpL).

Pure numpy/scipy, CPU-only, seconds-scale. These check the ALGEBRA / LEMMAS
behind Theorem 3.3 (Claim 1) and Theorem 3.7 (Claim 2), not paper outcomes.
Exit code 0 iff every check passes; prints PASS/FAIL per check.
"""
import math
import sys
import time

import numpy as np
from scipy.optimize import linear_sum_assignment
from scipy.special import gammaln

sys.path.insert(0, __file__.rsplit("/", 1)[0])
from exp01_affine_scaling import solve_gs  # noqa: E402

RESULTS = []


def record(name, ok, detail=""):
    RESULTS.append((name, bool(ok), detail))
    print(f"[{'PASS' if ok else 'FAIL'}] {name} {detail}")


def omega_d(d):
    return math.pi ** (d / 2.0) / math.exp(gammaln(d / 2.0 + 1))


# ---------------------------------------------------------------------------
# CHK-D1: distance-to-Lipschitz-graph inequality (Lemma 3.1)
# ---------------------------------------------------------------------------
def chk_d1():
    rng = np.random.default_rng(0)
    d = 5
    lam = rng.uniform(0.5, 3.0, size=d)
    A = np.diag(lam)
    L = lam.max()
    a = rng.normal(size=d)
    ok_lower, ok_upper = True, True
    IpA2_inv = np.linalg.inv(np.eye(d) + A @ A)
    for _ in range(200):
        x = rng.normal(size=d)
        y = rng.normal(size=d)
        xprime = IpA2_inv @ (x + A @ (y - a))
        Txp = A @ xprime + a
        g_min = np.sum((x - xprime) ** 2) + np.sum((y - Txp) ** 2)
        Tx = A @ x + a
        bias2 = np.sum((y - Tx) ** 2)
        if g_min < bias2 / (1 + L ** 2) - 1e-9:
            ok_lower = False
        if g_min > bias2 + 1e-9:
            ok_upper = False
    record("CHK-D1 lower: min_x' g(x') >= |y-T(x)|^2/(1+L^2)", ok_lower)
    record("CHK-D1 upper: min_x' g(x') <= |y-T(x)|^2", ok_upper)


# ---------------------------------------------------------------------------
# CHK-D2: fiberwise L2 lower bound (Lemma 3.2) + C0 formula
# ---------------------------------------------------------------------------
def chk_d2():
    rng = np.random.default_rng(1)
    Nx, Ny = 40, 25
    mu = np.full(Nx, 1.0 / Nx)
    H = rng.uniform(0.01, 1.0, size=(Nx, Ny))
    col_mass = (mu[:, None] * H).sum(axis=0)
    H = H / col_mass[None, :]  # enforce int h dmu = 1 per fiber y
    ok_cs = True
    for j in range(Ny):
        support = H[:, j] > 1e-15
        mu_Xy = mu[support].sum()
        lhs = np.sum(mu * H[:, j] ** 2)
        rhs = 1.0 / mu_Xy
        if lhs < rhs - 1e-10:
            ok_cs = False
    record("CHK-D2 Cauchy-Schwarz: int h^2 dmu >= 1/mu(X_y) per fiber", ok_cs)

    ms = rng.uniform(1e-6, 1.0, size=500)
    ok_mono = np.all(1.0 / ms >= 1.0 - 1e-12)
    record("CHK-D2 monotone: 1/mu(X_y) >= 1 for mu(X_y) in (0,1]", ok_mono)

    d, L, lam_nu = 7, 2.3, 0.6
    C0_direct = lam_nu * (1 + L ** 2) ** (d / 2.0) * omega_d(d)
    C0_formula = lam_nu * (1 + L ** 2) ** (d / 2.0) * (math.pi ** (d / 2.0) / math.exp(gammaln(d / 2.0 + 1)))
    record("CHK-D2 C0 formula self-consistency", abs(C0_direct - C0_formula) < 1e-9)


# ---------------------------------------------------------------------------
# CHK-D3: rate-scaling fit, d=1 self-transport, decisive in-regime check
# ---------------------------------------------------------------------------
def chk_d3():
    rng = np.random.default_rng(2)
    N = M = 150
    x = np.sort(rng.uniform(0, 1, size=N))
    y = np.sort(rng.uniform(0, 1, size=M))
    c = 0.5 * (x[:, None] - y[None, :]) ** 2
    c_med = float(np.median(c))

    row_ind, col_ind = linear_sum_assignment(c)
    OT_LP = c[row_ind, col_ind].sum() / N  # uniform weights 1/N each

    mults = np.geomspace(1e-3, 1e-1, 10)
    logs_eps, logs_delta = [], []
    f_prev = g_prev = None
    for m in mults[::-1]:
        eps = m * c_med
        tol = 1e-2 * eps
        f, g, converged, _ = solve_gs(c, eps, N, M, tol, 5000, f_prev, g_prev)
        f_prev, g_prev = f, g
        P = f[:, None] + g[None, :] - c
        pos = np.maximum(P, 0.0)
        pi = pos / (N * M * eps)
        cost = float(np.sum(c * pi))
        delta_eps = cost - OT_LP
        if delta_eps > 0:
            logs_eps.append(math.log(eps))
            logs_delta.append(math.log(delta_eps))
    logs_eps = np.array(logs_eps)
    logs_delta = np.array(logs_delta)
    Xm, Ym = logs_eps.mean(), logs_delta.mean()
    slope = float(np.sum((logs_eps - Xm) * (logs_delta - Ym)) / np.sum((logs_eps - Xm) ** 2))
    lo, hi = 2.0 / 3 - 0.15, 2.0 / 3 + 0.15
    ok = lo <= slope <= hi
    record("CHK-D3 value-gap rate slope in [0.517,0.817] (theory 2/(d+2)=0.667, d=1)",
           ok, f"slope={slope:.4f} n_pts={len(logs_eps)} OT_LP={OT_LP:.6g}")


# ---------------------------------------------------------------------------
# CHK-D4: exact reduction to self-transport (Fenchel-Young slack identity)
# ---------------------------------------------------------------------------
def chk_d4():
    rng = np.random.default_rng(3)
    d = 5
    Q = rng.normal(size=(d, d))
    A = Q @ Q.T + d * np.eye(d)  # SPD
    a = rng.normal(size=d)
    Ainv = np.linalg.inv(A)

    def phi(x):
        return 0.5 * x @ A @ x + a @ x

    def phi_star(y):
        z = y - a
        return 0.5 * z @ Ainv @ z

    ok = True
    for _ in range(50):
        x = rng.normal(size=d)
        v = rng.normal(size=d)
        Tv = A @ v + a
        Dphi = phi(x) + phi_star(Tv) - x @ Tv
        rhs = 0.5 * (v - x) @ A @ (v - x)
        if abs(Dphi - rhs) > 1e-9:
            ok = False
    record("CHK-D4 Fenchel-Young slack Dphi(x,T(v)) == 1/2<v-x,A(v-x)>", ok)

    # pushforward-norm invariance under F(x,v)=(x,T(v)): relabeling y=T(v)
    # preserves the coupling MASS matrix (only the y-coordinate is renamed),
    # so its L2(mu x mu) norm equals the L2(mu x nu) norm of the pushed density.
    Nx = 30
    Hxv = rng.uniform(0, 1, size=(Nx, Nx))
    norm_before = np.sqrt(np.mean(Hxv ** 2))
    Hxy = Hxv.copy()  # F relabels columns v_j -> y_j=T(v_j), values unchanged
    norm_after = np.sqrt(np.mean(Hxy ** 2))
    record("CHK-D4 pushforward norm invariance ||h||_{L2(mu x mu)} == ||h||_{L2(mu x nu)}",
           abs(norm_before - norm_after) < 1e-12)


# ---------------------------------------------------------------------------
# CHK-D5: whitening + tube transfer identity
# ---------------------------------------------------------------------------
def chk_d5():
    rng = np.random.default_rng(4)
    d = 6
    Q = rng.normal(size=(d, d))
    A = Q @ Q.T + d * np.eye(d)
    a = rng.normal(size=d)
    evals, evecs = np.linalg.eigh(A)
    A_sqrt = evecs @ np.diag(np.sqrt(evals)) @ evecs.T
    lam_max = evals.max()

    ok_eq, ok_ineq = True, True
    for _ in range(100):
        x = rng.normal(size=d)
        v = rng.normal(size=d)
        y = A @ v + a
        Tx = A @ x + a
        lhs = np.linalg.norm(y - Tx)
        u = A_sqrt @ x
        w = A_sqrt @ v
        rhs_exact = np.linalg.norm(A_sqrt @ (w - u))
        if abs(lhs - rhs_exact) > 1e-8:
            ok_eq = False
        if lhs > math.sqrt(lam_max) * np.linalg.norm(w - u) + 1e-8:
            ok_ineq = False
    record("CHK-D5 exact identity |y-T(x)| == |A^{1/2}(w-u)|", ok_eq)
    record("CHK-D5 operator-norm bound |y-T(x)| <= sqrt(lam_max)|w-u|", ok_ineq)


# ---------------------------------------------------------------------------
# CHK-D6a/b/c: Wiesel-Xu boundary algebra, rate arithmetic, regime magnitude
# ---------------------------------------------------------------------------
def chk_d6a():
    rng = np.random.default_rng(5)
    ok = True
    for _ in range(50):
        lam = rng.uniform(0.1, 1.0)
        kappa = rng.uniform(0.1, 1.0)
        wd = rng.uniform(0.5, 5.0)
        rA = rng.uniform(0.1, 2.0)
        eps0 = lam * kappa * wd * rA ** 2  # d+2 collapses to 2 in scalar test below via rstar def
        # r* defined implicitly by r*rho(sqrt(r*)) = eps, rho(s)=lam*kappa*wd*s^d ; use d=1 here
        d = 1
        eps0 = lam * kappa * wd * rA ** (d + 2)
        rstar = rA ** 2
        lhs = rstar * (lam * kappa * wd * (math.sqrt(rstar)) ** d)
        if abs(lhs - eps0) > 1e-9 * max(1, abs(eps0)):
            ok = False
    record("CHK-D6a boundary algebra: r*=rA^2 and r*rho(sqrt(r*))=eps0 at eps=eps0", ok)


def chk_d6b():
    ok = True
    details = []
    for d in (1, 10, 100):
        lam_max, lam_muA, kappa, wd = 2.0, 0.7, 0.4, 3.0
        eps_grid = np.geomspace(1e-6, 1e-2, 20)

        def bound(eps):
            return 8 * math.sqrt(lam_max) * (eps / (lam_muA * kappa * wd)) ** (1.0 / (d + 2))

        vals = np.array([bound(e) for e in eps_grid])
        logs_e = np.log(eps_grid)
        logs_v = np.log(vals)
        slope = np.diff(logs_v) / np.diff(logs_e)
        target = 1.0 / (d + 2)
        ok_d = np.allclose(slope, target, atol=1e-9)
        ok = ok and ok_d
        details.append(f"d={d} slope={slope.mean():.6f} target={target:.6f}")
    record("CHK-D6b rate arithmetic: log-log slope of bound == 1/(d+2)", ok, "; ".join(details))


def chk_d6c():
    d = 100
    log_wd = (d / 2.0) * math.log(math.pi) - gammaln(d / 2.0 + 1)
    r_A = 0.08
    log_eps0 = math.log(1.0) + math.log(1.0) + log_wd + (d + 2) * math.log(r_A)  # lam_muA=kappa=1 upper bound
    ok = log_eps0 < math.log(1e-100)
    record("CHK-D6c regime-boundary magnitude: eps_0(d=100) < 1e-100 (documents pre-asymptotic regime)",
           ok, f"log10(eps0) approx {log_eps0/math.log(10):.1f}")


def main():
    t0 = time.time()
    chk_d1()
    chk_d2()
    chk_d3()
    chk_d4()
    chk_d5()
    chk_d6a()
    chk_d6b()
    chk_d6c()
    dt = time.time() - t0
    n_pass = sum(1 for _, ok, _ in RESULTS if ok)
    n_total = len(RESULTS)
    print(f"\n=== derivation checks: {n_pass}/{n_total} PASS ({dt:.2f}s) ===")
    sys.exit(0 if n_pass == n_total else 1)


if __name__ == "__main__":
    main()