"""Claims 4-6: audit of Table 1 in arXiv:2602.01399v1.

All three claims make specific numerical assertions *about Table 1 of the
paper*, so the primary evidence is the table itself.  We pin the PDF by SHA-256,
transcribe Table 1 from the extracted text, and check each assertion.
"""
import hashlib
import json

import numpy as np

PDF = "paper.pdf"
SHA = hashlib.sha256(open(PDF, "rb").read()).hexdigest()

# Benchmarks in column order, with their stated dimension d and budget m.
BENCH = [
    ("DistilBERT", 14, 1440, "deep learning (text)"),
    ("Estate", 15, 1722, "tabular"),
    ("ViT16", 16, 1705, "deep learning (vision)"),
    ("Cancer", 30, 2281, "tabular"),
    ("IL60", 60, 5521, "tabular"),
    ("CG60", 60, 5521, "tabular"),
    ("NHANES", 79, 5864, "tabular"),
    ("Crime", 101, 11126, "tabular"),
]

# Table 1, transcribed from the pinned PDF.  None = the paper leaves the cell
# blank for that estimator/benchmark pair.
NAN = None
TABLE = {
    "MSR":              ([7.5e-4, 2.8e-2, 1.2e-4, 2.2e-2, 3.5e-3, 2.1e-3, 4.7e-2, 3.6e+1], 7.75),
    "SV ARM":           ([3.7e-4, 3.3e-2, 5.7e-5, 3.5e-3, 2.2e-3, 9.7e-4, 4.0e-2, 1.5e+1], 6.75),
    "PermutationSampling": ([6.2e-4, 5.3e-3, 1.2e-4, 1.1e-4, 1.3e-4, 1.4e-4, 3.5e-3, 2.7e+0], 5.62),
    "LeverageSHAP":     ([7.7e-5, 3.4e-4, 3.5e-5, 3.2e-5, 2.6e-5, 2.5e-5, 6.2e-4, 7.5e-1], 3.25),
    "PolySHAP-3":       ([8.0e-5, 3.2e-7, 3.8e-5, 4.0e-5, NAN, NAN, NAN, NAN], 3.25),
    "RegressionMSR":    ([3.1e-5, 1.3e-5, 1.0e-5, 3.0e-4, 9.7e-6, 7.6e-5, 2.4e-4, 5.6e-1], 2.62),
    "Proxy":            ([3.6e-4, 3.3e-5, 4.6e-5, 4.2e-4, 4.9e-5, 2.9e-4, 7.0e-4, 5.3e+0], 5.00),
    "FFD-RD":           ([1.6e-3, 1.8e-6, 5.3e-4, 6.4e-7, NAN, NAN, NAN, NAN], 5.75),
    "FFD-RD-Corrected": ([1.8e-3, 6.8e-5, NAN, NAN, NAN, NAN, NAN, NAN], 8.50),
    "FourierSHAP":      ([1.9e-2, 3.0e-2, 4.9e-3, 7.7e-2, 4.1e-3, 8.5e-3, 1.7e-1, 1.9e+2], 9.12),
    "OddSHAP":          ([4.6e-5, 5.1e-7, 1.3e-5, 4.2e-6, 1.6e-6, 6.2e-6, 5.8e-5, 1.3e-1], 1.50),
}

out = {"pdf_sha256": SHA, "n_pages": 25,
       "benchmarks": [{"name": b, "d": d, "m": m, "kind": k}
                      for b, d, m, k in BENCH]}

names = list(TABLE)
ranks = {k: v[1] for k, v in TABLE.items()}
best = min(ranks, key=ranks.get)
second = sorted(ranks, key=ranks.get)[1]

# ------------------------------------------------------------------ claim 4
out["claim4"] = {
    "assertion_n_estimators": 8,
    "actual_n_estimator_rows": len(names),
    "estimator_rows": names,
    "n_estimators_matches": bool(len(names) == 8),
    "assertion_n_benchmarks": 8,
    "actual_n_benchmarks": len(BENCH),
    "n_benchmarks_matches": bool(len(BENCH) == 8),
    "assertion_oddshap_rank": 1.50,
    "actual_oddshap_rank": ranks["OddSHAP"],
    "oddshap_rank_matches": bool(abs(ranks["OddSHAP"] - 1.50) < 1e-9),
    "oddshap_is_lowest_rank": bool(best == "OddSHAP"),
    "assertion_regressionmsr_rank": 2.25,
    "actual_regressionmsr_rank": ranks["RegressionMSR"],
    "regressionmsr_rank_matches": bool(abs(ranks["RegressionMSR"] - 2.25) < 1e-9),
    "second_best_estimator": second,
    "all_ranks": ranks,
}
out["claim4"]["verdict"] = (
    "FALSIFIED: OddSHAP's rank (1.50) and its first-place finish are correct, "
    "and there are indeed 8 benchmarks, but the table lists "
    f"{len(names)} estimator rows rather than 8, and RegressionMSR's average "
    f"rank is {ranks['RegressionMSR']}, not 2.25.")

# ------------------------------------------------------------------ claim 5
lev = TABLE["LeverageSHAP"][0]
odd = TABLE["OddSHAP"][0]
rows5 = []
for i, (b, d, m, kind) in enumerate(BENCH):
    if lev[i] is None or odd[i] is None:
        continue
    rows5.append({"benchmark": b, "d": d, "kind": kind,
                  "leverageshap_mse": lev[i], "oddshap_mse": odd[i],
                  "ratio": lev[i] / odd[i]})
tab = [r for r in rows5 if r["kind"] == "tabular"]
allr = [r["ratio"] for r in rows5]
tabr = [r["ratio"] for r in tab]
out["claim5"] = {
    "rows": rows5,
    "claimed_interval": [6.0, 62.0],
    "tabular_only": {"n": len(tab), "min_ratio": min(tabr), "max_ratio": max(tabr),
                     "ratios": {r["benchmark"]: r["ratio"] for r in tab},
                     "n_inside_interval": sum(1 for x in tabr if 6 <= x <= 62),
                     "n_below_6": sum(1 for x in tabr if x < 6),
                     "n_above_62": sum(1 for x in tabr if x > 62)},
    "all_benchmarks": {"n": len(rows5), "min_ratio": min(allr), "max_ratio": max(allr)},
}
out["claim5"]["verdict"] = (
    "FALSIFIED: on the paper's own tabular benchmarks the LeverageSHAP/OddSHAP "
    f"MSE ratio spans {min(tabr):.2f}x to {max(tabr):.1f}x, which falls outside "
    "the claimed 6-62x band at BOTH ends.")

# ------------------------------------------------------------------ claim 6
# Four estimator rows in Table 1 are only partially filled (PolySHAP-3, FFD-RD,
# FFD-RD-Corrected).  In the linearised PDF text their numbers cannot be
# assigned to columns unambiguously, so the "best baseline" per benchmark is
# computed over the estimators with COMPLETE rows only.  The partial rows are
# reported separately and excluded from the comparison rather than guessed.
COMPLETE = [k for k, v in TABLE.items() if all(x is not None for x in v[0])]
PARTIAL = [k for k in TABLE if k not in COMPLETE]

rows6 = []
for i, (b, d, m, kind) in enumerate(BENCH):
    base = {k: TABLE[k][0][i] for k in COMPLETE if k != "OddSHAP"}
    bb = min(base, key=base.get)
    rows6.append({"benchmark": b, "d": d, "best_baseline": bb,
                  "best_baseline_mse": base[bb], "oddshap_mse": odd[i],
                  "advantage": base[bb] / odd[i]})
lo = [r for r in rows6 if r["d"] < 30]
hi = [r for r in rows6 if r["d"] >= 30]
argmax = max(rows6, key=lambda r: r["advantage"])
out["claim6"] = {
    "complete_rows_used": COMPLETE,
    "partial_rows_excluded": PARTIAL,
    "exclusion_reason": ("these rows have blank cells in Table 1 and the "
                         "linearised PDF text does not determine which "
                         "benchmarks their numbers belong to"),
    "rows": rows6,
    "max_advantage_benchmark": argmax["benchmark"],
    "max_advantage_d": argmax["d"],
    "max_advantage": argmax["advantage"],
    "low_dim_d_lt_30": {"n": len(lo),
                        "max_advantage": max(r["advantage"] for r in lo),
                        "median_advantage": float(np.median([r["advantage"] for r in lo]))},
    "high_dim_d_ge_30": {"n": len(hi),
                         "max_advantage": max(r["advantage"] for r in hi),
                         "median_advantage": float(np.median([r["advantage"] for r in hi]))},
    "n_benchmarks_where_oddshap_loses": sum(1 for r in rows6 if r["advantage"] < 1),
}
out["claim6"]["n_wins_d_lt_30"] = sum(1 for r in lo if r["advantage"] > 1)
out["claim6"]["n_wins_d_ge_30"] = sum(1 for r in hi if r["advantage"] > 1)
out["claim6"]["reading_maximum"] = {
    "argmax_d": argmax["d"], "argmax_advantage": argmax["advantage"],
    "supports_claim": bool(argmax["d"] >= 30)}
out["claim6"]["reading_median"] = {
    "median_lt_30": float(np.median([r["advantage"] for r in lo])),
    "median_ge_30": float(np.median([r["advantage"] for r in hi])),
    "supports_claim": bool(np.median([r["advantage"] for r in hi]) >
                           np.median([r["advantage"] for r in lo]))}
out["claim6"]["reading_consistency"] = {
    "wins_lt_30": f"{out['claim6']['n_wins_d_lt_30']}/{len(lo)}",
    "wins_ge_30": f"{out['claim6']['n_wins_d_ge_30']}/{len(hi)}",
    "supports_claim": bool(
        out["claim6"]["n_wins_d_ge_30"] / len(hi) >
        out["claim6"]["n_wins_d_lt_30"] / len(lo))}
out["claim6"]["verdict"] = (
    "MIXED, and we decline to call it falsified. Table 1 at m~100d answers the "
    "claim differently depending on what 'largest advantage' means. Under a "
    f"single-maximum reading the claim FAILS: the biggest advantage is "
    f"{argmax['advantage']:.1f}x at d={argmax['d']} ({argmax['benchmark']}), below 30. "
    "Under a median or consistency reading the claim HOLDS: the median "
    f"advantage is {float(np.median([r['advantage'] for r in hi])):.2f}x at d>=30 versus "
    f"{float(np.median([r['advantage'] for r in lo])):.2f}x below 30, and OddSHAP beats "
    f"every complete-row baseline on {out['claim6']['n_wins_d_ge_30']}/{len(hi)} of the "
    f"d>=30 benchmarks but only {out['claim6']['n_wins_d_lt_30']}/{len(lo)} of the smaller "
    "ones. The d<30 group is bimodal (one 25.5x win, two losses) while the "
    "d>=30 group is uniformly 4-8x, so the maximum is an outlier and the "
    "typical behaviour supports the paper.")

json.dump(out, open("outputs_table1.json", "w"), indent=2)

print("SHA256", SHA)
print("\n--- claim 4")
print(" estimator rows:", len(names), "->", names)
print(" OddSHAP rank", ranks["OddSHAP"], "| RegressionMSR rank", ranks["RegressionMSR"])
print(" ", out["claim4"]["verdict"])
print("\n--- claim 5 (LeverageSHAP / OddSHAP MSE ratio)")
for r in rows5:
    print(f"   {r['benchmark']:<18} d={r['d']:<4} {r['kind']:<22} ratio {r['ratio']:>9.2f}x")
print(" ", out["claim5"]["verdict"])
print("\n--- claim 6 (advantage over best COMPLETE-row baseline)")
print("   excluded partial rows:", out["claim6"]["partial_rows_excluded"])
for r in rows6:
    print(f"   {r['benchmark']:<18} d={r['d']:<4} best={r['best_baseline']:<16} "
          f"advantage {r['advantage']:>8.2f}x")
print(" ", out["claim6"]["verdict"])