#!/usr/bin/env python3
"""Independently re-derive the screening-ceiling dataset. Zero dependencies.

Standard library only -- no numpy, no maxwell-lint, nothing from the repository
that produced the data. Point it at `data/` and it rebuilds the physics from the
published geometry and checks both claims:

  * the UNIVERSAL claim, by sampling inside every certified region and confirming
    no sampled layout exceeds k_bar;
  * the EXISTENTIAL claim, by recomputing each counterexample from its stored
    coordinates and confirming the extractor really does predict k > 1.

Sampling cannot prove the universal claim -- that is what the interval
branch-and-bound in the source proof is for, and no amount of sampling
substitutes for it. What sampling can do is REFUTE it, and that is the useful
thing an independent reader wants: a cheap, dependency-free way to try to catch
us being wrong.

Run:
    python3 verify.py                # check the committed data
    python3 verify.py --samples 200  # sample harder
    python3 verify.py --self-test    # prove the checker still discriminates
"""
from __future__ import annotations

import argparse
import json
import math
import pathlib
import random
import sys

HERE = pathlib.Path(__file__).resolve().parent
DATA = HERE / "data"


# ------------------------------------------------------------------ linear algebra

def inverse(m: list[list[float]]) -> list[list[float]]:
    """Gauss-Jordan inverse with partial pivoting. Small dense matrices only."""
    n = len(m)
    a = [row[:] + [1.0 if i == j else 0.0 for j in range(n)] for i, row in enumerate(m)]
    for col in range(n):
        piv = max(range(col, n), key=lambda r: abs(a[r][col]))
        if abs(a[piv][col]) < 1e-300:
            raise ZeroDivisionError("singular potential matrix")
        a[col], a[piv] = a[piv], a[col]
        d = a[col][col]
        a[col] = [x / d for x in a[col]]
        for r in range(n):
            if r == col:
                continue
            f = a[r][col]
            if f:
                a[r] = [x - f * y for x, y in zip(a[r], a[col])]
    return [row[n:] for row in a]


# ---------------------------------------------------------------------- physics

def potential_matrix(xy: list[list[float]], radius: list[float]) -> list[list[float]]:
    """Maxwell potential coefficients, thin-wire/monopole form.

    The 1/(2*pi*eps0*eps_r) prefactor is omitted deliberately: k is a ratio of
    two capacitances computed from the same medium, so the prefactor cancels
    exactly. Carrying it would only add rounding.
    """
    n = len(xy)
    p = [[0.0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            if i == j:
                p[i][j] = -math.log(radius[i])
            else:
                dx = xy[i][0] - xy[j][0]
                dy = xy[i][1] - xy[j][1]
                p[i][j] = -math.log(math.hypot(dx, dy))
    return p


def isolated_pair_coupling(ri: float, rj: float, r: float) -> float:
    """|C_ij| for the pair alone -- the denominator of k."""
    p = [[-math.log(ri), -math.log(r)], [-math.log(r), -math.log(rj)]]
    return abs(inverse(p)[0][1])


def screening_factors(xy: list[list[float]], radius: list[float]) -> list[list[float]]:
    """k_ij = |C_ij(full array)| / |C_ij(pair alone)| for every off-diagonal pair."""
    n = len(xy)
    c = inverse(potential_matrix(xy, radius))
    k = [[0.0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            if i == j:
                continue
            r = math.hypot(xy[i][0] - xy[j][0], xy[i][1] - xy[j][1])
            iso = isolated_pair_coupling(radius[i], radius[j], r)
            k[i][j] = abs(c[i][j]) / iso if iso > 0 else 0.0
    return k


def family_layout(d0_um: float, pt_mult: float, sep_mult: float, jog_mult: float):
    """The two-tight-pairs family geometry, in metres.

    pitch = 1.6 * d0 * pt_mult, separation = pitch * sep_mult, jog = jog_mult *
    separation; four equal conductors of diameter d0 at (0,0), (pitch,0),
    (separation,jog), (separation+pitch,jog).
    """
    pt = 1.6 * d0_um * pt_mult * 1e-6
    sep = pt * sep_mult
    jog = jog_mult * sep
    xy = [[0.0, 0.0], [pt, 0.0], [sep, jog], [sep + pt, jog]]
    return xy, [d0_um * 1e-6 / 2.0] * 4


def max_family_k(d0_um: float, pt_mult: float, sep_mult: float, jog_mult: float) -> float:
    xy, radius = family_layout(d0_um, pt_mult, sep_mult, jog_mult)
    k = screening_factors(xy, radius)
    return max(k[i][j] for i in range(4) for j in range(4) if i != j)


def born_second_order_k(xy, radius) -> list[list[float]]:
    """Re-derive the failing extractor: second-order truncation of the inverse."""
    n = len(xy)
    p = potential_matrix(xy, radius)
    dinv = [[1.0 / p[i][i] if i == j else 0.0 for j in range(n)] for i in range(n)]
    r = [[0.0 if i == j else p[i][j] for j in range(n)] for i in range(n)]
    a = [[sum(dinv[i][t] * r[t][j] for t in range(n)) for j in range(n)] for i in range(n)]
    a2 = [[sum(a[i][t] * a[t][j] for t in range(n)) for j in range(n)] for i in range(n)]
    mid = [[(1.0 if i == j else 0.0) - a[i][j] + a2[i][j] for j in range(n)]
           for i in range(n)]
    approx = [[sum(mid[i][t] * dinv[t][j] for t in range(n)) for j in range(n)]
              for i in range(n)]
    k = [[0.0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            if i == j:
                continue
            d = math.hypot(xy[i][0] - xy[j][0], xy[i][1] - xy[j][1])
            iso = isolated_pair_coupling(radius[i], radius[j], d)
            k[i][j] = abs(approx[i][j]) / iso if iso > 0 else 0.0
    return k


# ---------------------------------------------------------------------- checks

def check_regions(regions, k_bar, samples, rng, verbose=True):
    worst, worst_at, violations = 0.0, None, []
    for reg in regions:
        b = reg["bounds"]
        for _ in range(samples):
            pt = {n: rng.uniform(b[n]["lo"], b[n]["hi"]) for n in b}
            k = max_family_k(pt["d0_um"], pt["pt_mult"], pt["sep_mult"], pt["jog_mult"])
            if k > worst:
                worst, worst_at = k, (reg["region_id"], pt)
            if k > k_bar:
                violations.append({"region": reg["region_id"], "point": pt, "k": k})
    if verbose:
        print(f"  regions            {len(regions)} x {samples} samples "
              f"= {len(regions) * samples} layouts")
        print(f"  worst sampled k    {worst:.12f}   (bound {k_bar:.12f})")
        print(f"  margin to bound    {k_bar - worst:.12f}")
        print(f"  violations         {len(violations)}")
        if worst_at:
            rid, p = worst_at
            print(f"  worst at           region {rid}  "
                  + " ".join(f"{n}={v:.4f}" for n, v in sorted(p.items())))
    return worst, violations


def check_counterexamples(cases, verbose=True):
    confirmed, failed = 0, []
    for c in cases:
        xy = [[x * 1e-6, y * 1e-6] for x, y in c["xy_um"]]
        radius = [r * 1e-6 for r in c["radius_um"]]
        k = born_second_order_k(xy, radius)
        n = len(xy)
        kmax = max(k[i][j] for i in range(n) for j in range(n) if i != j)
        if kmax > 1.0 and abs(kmax - c["k_predicted"]) < 1e-6:
            confirmed += 1
        else:
            failed.append({"case_id": c["case_id"], "recomputed": kmax,
                           "published": c["k_predicted"]})
    if verbose:
        print(f"  counterexamples    {confirmed}/{len(cases)} re-derived "
              f"and confirmed above the ceiling")
        for f in failed[:5]:
            print(f"    MISMATCH {f['case_id']}: "
                  f"recomputed {f['recomputed']:.9f} vs published {f['published']:.9f}")
    return confirmed, failed


def load():
    regions = [json.loads(x) for x in
               (DATA / "certified_regions.jsonl").read_text(encoding="utf-8").splitlines() if x.strip()]
    cases = [json.loads(x) for x in
             (DATA / "counterexamples.jsonl").read_text(encoding="utf-8").splitlines() if x.strip()]
    theorem = json.loads((DATA / "theorem.json").read_text(encoding="utf-8"))
    return regions, cases, theorem


def self_test() -> int:
    """A checker that cannot fail is not a checker. Prove it still discriminates."""
    print("negative control")
    rng = random.Random(0)
    ok = True

    # 1. an impossible bound must be violated by sampling
    regions, _, _ = load()
    _, viol = check_regions(regions[:4], k_bar=0.5, samples=5, rng=rng, verbose=False)
    hit = len(viol) > 0
    print(f"  [{'REJECTED' if hit else 'MISSED  '}] fabricated bound k_bar=0.5")
    ok &= hit

    # 2. a tampered counterexample value must not re-derive
    _, cases, _ = load()
    bad = dict(cases[0], k_predicted=cases[0]["k_predicted"] * 1.5)
    _, failed = check_counterexamples([bad], verbose=False)
    print(f"  [{'REJECTED' if failed else 'MISSED  '}] tampered k_predicted")
    ok &= bool(failed)

    # 3. a layout with the pair alone must give k == 1 (no screening to find)
    xy, radius = [[0.0, 0.0], [1e-4, 0.0]], [2e-5, 2e-5]
    k = screening_factors(xy, radius)[0][1]
    near1 = abs(k - 1.0) < 1e-9
    print(f"  [{'PASSED  ' if near1 else 'FAILED  '}] isolated pair reproduces k = 1 "
          f"({k:.12f})")
    ok &= near1

    print(f"\n  checker discriminates: {ok}")
    return 0 if ok else 3


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--samples", type=int, default=25,
                    help="interior samples per certified region (default 25)")
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--self-test", action="store_true")
    args = ap.parse_args()

    if args.self_test:
        return self_test()

    if not DATA.exists():
        print(f"no data directory at {DATA}", file=sys.stderr)
        return 2

    regions, cases, theorem = load()
    k_bar = theorem["k_bar"]
    print("screening-ceiling  independent re-derivation (stdlib only)\n")
    print(f"  claim              k <= {k_bar:.12f} for every layout in the family")
    print(f"  forced error       pairwise over-predicts by >= "
          f"{theorem['forced_pairwise_overprediction_pct']:.4f}%\n")

    rng = random.Random(args.seed)
    worst, violations = check_regions(regions, k_bar, args.samples, rng)
    print()
    confirmed, failed = check_counterexamples(cases)

    bad = bool(violations) or bool(failed)
    print()
    if bad:
        print("  REFUTED -- the published claim does not survive re-derivation")
    else:
        print("  consistent: no sampled layout exceeds the bound, and every "
              "counterexample re-derives")
    print(f"\n  scope: {theorem['honest_scope']}")
    return 1 if bad else 0


if __name__ == "__main__":
    raise SystemExit(main())