hilbert-sharpness-v2/verify_hilbert_sharpness.py

#!/usr/bin/env python3
"""Fail-closed audit of the Hilbert-space sharpness campaign outputs."""
from __future__ import annotations

import argparse
import csv
import json
from pathlib import Path

import numpy as np


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--results", type=Path, default=Path("results/hilbert_sharpness"))
    args = parser.parse_args()
    with (args.results / "hilbert_sharpness.csv").open() as handle:
        rows = list(csv.DictReader(handle))

    dims = sorted({int(r["dimension"]) for r in rows})
    ns = sorted({int(r["n"]) for r in rows})
    assert dims == [2, 32, 512], dims
    assert ns == [500, 2000, 10000, 50000, 200000], ns
    assert len(rows) == len(dims) * len(ns)

    sigma2 = (0.20**2 + 0.45**2) / 2
    v4 = ((0.20**2 - sigma2) ** 2 + (0.45**2 - sigma2) ** 2) / 2
    oracle = np.sqrt(2 * v4 * np.log(20))
    assert all(abs(float(r["oracle_scaled_width"]) - oracle) < 1e-12 for r in rows)
    assert all(float(r["support_max_norm"]) <= 0.5 for r in rows)
    assert all(int(r["active_lower_paths"]) == int(r["paths"]) for r in rows)

    for d in dims:
        group = sorted((r for r in rows if int(r["dimension"]) == d), key=lambda r: int(r["n"]))
        upper_err = [float(r["upper_relative_error"]) for r in group]
        lower_radius_err = [float(r["lower_radius_relative_error"]) for r in group]
        penalties = [float(r["lower_mean_penalty_scaled_mean"]) for r in group]
        assert all(b < a for a, b in zip(upper_err, upper_err[1:])), (d, upper_err)
        assert all(b < a for a, b in zip(lower_radius_err, lower_radius_err[1:])), (d, lower_radius_err)
        assert all(b < a for a, b in zip(penalties, penalties[1:])), (d, penalties)
        assert upper_err[-1] < 0.025, (d, upper_err[-1])
        assert lower_radius_err[-1] < 0.04, (d, lower_radius_err[-1])

    max_rows = [r for r in rows if int(r["n"]) == max(ns)]
    upper_spread = max(float(r["upper_scaled_width_mean"]) for r in max_rows) - min(
        float(r["upper_scaled_width_mean"]) for r in max_rows
    )
    lower_spread = max(float(r["lower_scaled_width_mean"]) for r in max_rows) - min(
        float(r["lower_scaled_width_mean"]) for r in max_rows
    )
    assert upper_spread < 2e-5
    assert lower_spread < 0.004

    report = {
        "status": "passed",
        "rows": len(rows),
        "dimensions": dims,
        "sample_sizes": ns,
        "paths_per_setting": int(rows[0]["paths"]),
        "total_paths": sum(int(r["paths"]) for r in rows),
        "oracle_recomputed": float(oracle),
        "max_n_max_upper_relative_error": max(float(r["upper_relative_error"]) for r in max_rows),
        "max_n_max_lower_radius_relative_error": max(
            float(r["lower_radius_relative_error"]) for r in max_rows
        ),
        "mean_penalty_strictly_decreases": True,
        "dimension_spread_at_max_n": {"upper": upper_spread, "lower_total": lower_spread},
    }
    (args.results / "independent_verification.json").write_text(json.dumps(report, indent=2) + "\n")
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()