"""Exact finite counterexample: cheaper repair need not be a better improver.

Python 3.10+, standard library only. Run from the research directory:
    python3 src/verify_pair.py --out results/pair_counterexample.json

Enumerates every degree -1 singleton proposal and every matrix-unit input to
the pair's higher-homotopy identity. No sampled trials or floating-point algebra.
"""
from __future__ import annotations

import argparse
from fractions import Fraction
import json
from pathlib import Path

from core import (Meter, Problem, add, differential, K, mul, nnz, positions,
                  repaired_candidate, valid)


def example():
    names = ("x", "u", "b", "c", "v", "y", "w")
    x, u, b, c, v, y, w = range(7)
    d = [0] * 7
    d[b] = 1 << x
    d[y] = 1 << c
    h0 = [0] * 7
    h0[x] = 1 << b
    h0[c] = 1 << y
    h1 = [0] * 7
    h1[x] = (1 << b) | (1 << c)
    h1[c] = 1 << y
    h1[b] = 1 << y
    Q = tuple(1 << j if j in (u, v, w) else 0 for j in range(7))
    P = tuple((1 << j) ^ Q[j] for j in range(7))
    problem = Problem(tuple(d), Q, P, tuple(h0), (0, 0, 1, 1, 1, 2, 2))
    return problem, tuple(h0), tuple(h1), names


def verify():
    p, work, generator, names = example()
    assert valid(p, work, Meter())
    assert valid(p, generator, Meter())
    # B = w*g; partial B = g-w (minus equals plus over GF(2)).
    B = mul(work, generator, Meter())
    assert differential(p, B, Meter()) == add(generator, work, Meter())

    def L(f):
        m = Meter()
        return add(mul(B, f, m), mul(mul(p.Q, f, m), B, m), m)

    verified_units = 0
    for i in range(p.n):
        for j in range(p.n):
            f = [0] * p.n
            f[i] = 1 << j
            f = tuple(f)
            m = Meter()
            lhs = add(K(p, generator, f, m), K(p, work, f, m), m)
            rhs = add(differential(p, L(f), m), L(differential(p, f, m)), m)
            assert lhs == rhs
            verified_units += 1

    available = positions(p, -1, Meter())
    records = []
    for label, gen in (("sparse_h0", work), ("denser_h1", generator)):
        trials = []
        for i, j in available:
            a = [0] * p.n
            a[i] = 1 << j
            meter = Meter()
            child = repaired_candidate(p, generator, gen, tuple(a), meter)
            is_valid = valid(p, child, meter)
            score = nnz(child, meter)
            success = child == work
            assert is_valid
            assert success or child == generator
            trials.append({"proposal": f"{names[j]}->{names[i]}",
                           "success": success, "valid": is_valid,
                           "child_nnz": score,
                           "candidate_check_score_work": meter.used})
        successes = sum(t["success"] for t in trials)
        probability = Fraction(successes, len(trials))
        mean_cost = Fraction(sum(t["candidate_check_score_work"]
                                 for t in trials), len(trials))
        proposal_cost = p.n + 7
        records.append({
            "generator": label,
            "generator_nnz": nnz(gen, Meter()),
            "successes": successes,
            "proposal_count": len(trials),
            "success_probability_exact": str(probability),
            "mean_candidate_check_score_work_exact": str(mean_cost),
            "expected_discovery_work_excluding_setup_and_proposal_exact":
                str(mean_cost / probability),
            "common_proposal_cost": proposal_cost,
            "expected_discovery_work_including_proposal_excluding_setup_exact":
                str((mean_cost + proposal_cost) / probability),
            "trials": trials,
        })
    assert records[0]["successes"] == 1
    assert records[1]["successes"] == 2
    return {
        "field": "GF(2)", "dimension": p.n, "names": names,
        "grades": p.grades,
        "scope": "exact finite counterexample, not a broad benchmark",
        "fixed_child": "h1",
        "pair_witness_nonzero_entries": ["y->x"],
        "pair_witness_orientation": "B = work * generator; partial B = generator - work",
        "pair_witness_verified": True,
        "higher_homotopy_basis_checks": verified_units,
        "cost_warning": "Expected work excludes discovery/selection of the "
                        "generator and one-time setup. Meter costs are not "
                        "hardware timings. All parent/pair costs must be "
                        "charged in a comparative RSI experiment.",
        "results": records,
    }


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--out", default="results/pair_counterexample.json")
    args = parser.parse_args()
    result = verify()
    out = Path(args.out)
    out.parent.mkdir(parents=True, exist_ok=True)
    out.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
    print(json.dumps({"output": str(out), "pair_witness_verified": True,
                      "higher_homotopy_basis_checks":
                          result["higher_homotopy_basis_checks"],
                      "success_probabilities":
                          [r["success_probability_exact"]
                           for r in result["results"]]}, indent=2))