#!/usr/bin/env python3
"""Finite, source-faithful construction audits for arXiv:2604.17505.

The public proof establishes the asymptotic statements.  This program executes
the exact finite membership-query objects in Algorithms 1--3 and the explicit
lower-bound family, with deliberate hypothesis-removal controls.
"""
from __future__ import annotations

from fractions import Fraction
import itertools
import json
import math
import os
import platform
import random
import subprocess
import sys
import time
from pathlib import Path

from claim3_scaling import run_claim3_scaling
from claim3_exhaustive import run_claim3_exhaustive
from claim1_deterministic import run_claim1_deterministic
from claim5_prediction import run_claim5_prediction
from claim4_lower_bound import run_claim4_lower_bound
from claim2_randomized import run_claim2_randomized
from report_assets import generate_report_assets

ROOT = Path(__file__).resolve().parents[2]
OUT = ROOT / "outputs"


class Agent:
    def __init__(self, utility, threshold):
        self.utility = tuple(Fraction(x) for x in utility)
        self.threshold = Fraction(threshold)
        self.queries = 0

    def accepts(self, x):
        self.queries += 1
        return sum(u * q for u, q in zip(self.utility, x)) >= self.threshold

    def exact_accepts(self, x):
        return sum(u * q for u, q in zip(self.utility, x)) >= self.threshold


def vertex(m, j):
    return tuple(Fraction(int(k == j)) for k in range(m))


def threshold(agent, rejected, accepted, eps):
    """Algorithm 1's ExactThreshold: binary query + bounded-denominator recovery."""
    lo, hi = Fraction(0), Fraction(1)
    while hi - lo >= eps * eps / 2:
        mid = (lo + hi) / 2
        x = tuple((1 - mid) * a + mid * b for a, b in zip(vertex(len(agent.utility), rejected), vertex(len(agent.utility), accepted)))
        if agent.accepts(x):
            hi = mid
        else:
            lo = mid
    qmax = int(1 / eps)
    choices = []
    for q in range(1, qmax + 1):
        p = math.ceil(q * lo)
        if Fraction(p, q) <= hi:
            choices.append(Fraction(p, q))
    assert len(set(choices)) == 1
    return choices[0]


def learn_hyperplane(agent, eps):
    """Literal Algorithm 1, returning source normalized c or sentinel."""
    m = len(agent.utility)
    acc = [j for j in range(m) if agent.accepts(vertex(m, j))]
    rej = [j for j in range(m) if j not in acc]
    if not rej:
        return "ACCEPT_ALL"
    if not acc:
        return "REJECT_ALL"
    r = rej[0]
    arj = {j: threshold(agent, r, j, eps) for j in acc}
    if all(a == 1 for a in arj.values()):
        return tuple(Fraction(int(j in acc)) for j in range(m))
    a = next(j for j, alpha in arj.items() if alpha < 1)
    c = [Fraction(0) for _ in range(m)]
    for j, alpha in arj.items():
        c[j] = 1 / alpha
    for k in rej:
        if k == r:
            continue
        alpha = threshold(agent, k, a, eps)
        c[k] = (1 - alpha * c[a]) / (1 - alpha)
    return tuple(c)


def satisfies(c, x):
    if c == "ACCEPT_ALL":
        return True
    if c == "REJECT_ALL":
        return False
    return sum(a * b for a, b in zip(c, x)) >= 1


def simplex_grid(m, denom):
    for prefix in itertools.product(range(denom + 1), repeat=m - 1):
        tail = denom - sum(prefix)
        if tail >= 0:
            yield tuple(Fraction(v, denom) for v in (*prefix, tail))


def select_grid(constraints, m, denom=120):
    """Independent finite LP solver: enumerate the stated quantized simplex."""
    feasible = [x for x in simplex_grid(m, denom) if all(satisfies(c, x) for c in constraints)]
    return max(feasible) if feasible else None


def deterministic(agents, eps, order=None):
    """Algorithm 2, with an independent finite-grid Select implementation."""
    m, unlearned, constraints = len(agents[0].utility), set(range(len(agents))), []
    order = list(range(len(agents))) if order is None else list(order)
    steps = 0
    while True:
        steps += 1
        x = select_grid(constraints, m)
        if x is None:
            return None, steps, len(constraints)
        violator = next((i for i in order if i in unlearned and not agents[i].accepts(x)), None)
        if violator is None:
            return x, steps, len(constraints)
        c = learn_hyperplane(agents[violator], eps)
        unlearned.remove(violator)
        if c == "REJECT_ALL":
            return None, steps, len(constraints) + 1
        constraints.append(c)


def reset(agents):
    for a in agents:
        a.queries = 0


def c1_learn_hyperplane():
    eps = Fraction(1, 10)
    templates = [
        ((0, 5, 10), 5), ((2, 8, 10), 6), ((0, 7, 9), 4),
        ((1, 4, 10), 5), ((0, 10, 10), 10),
    ]
    checked = 0
    for utility, tau in templates:
        agent = Agent([Fraction(v, 10) for v in utility], Fraction(tau, 10))
        c = learn_hyperplane(agent, eps)
        for x in simplex_grid(3, 30):
            assert satisfies(c, x) == agent.exact_accepts(x)
            checked += 1
        assert agent.queries <= 3 + 2 * math.ceil(math.log2(2 / float(eps * eps)))
    # Removing quantization makes the unique rational recovery premise false.
    unquantized = Agent((0, 1, 1), Fraction(1, 11))
    assert unquantized.threshold.denominator > int(1 / eps)
    return {"passed": True, "source": "Algorithm 1; Lemmas 3.1--3.2",
            "mechanism": "literal edge bisection/rational recovery and independent simplex evaluation",
            "cells": checked, "negative_control": {"unquantized_threshold_breaks_bounded_denominator": True},
            "scope": "all grid lotteries for five source-model quantized halfspaces."}


def c2_deterministic_feasibility():
    eps = Fraction(1, 10)
    feasible = [Agent((1, 0, 0), Fraction(3, 10)), Agent((0, 1, 0), Fraction(3, 10)), Agent((0, 0, 1), Fraction(2, 10))]
    x, rounds, learned = deterministic(feasible, eps)
    assert x is not None and all(a.exact_accepts(x) for a in feasible) and learned <= 3
    # An incompatible pair must yield the paper's Null/infeasibility outcome.
    infeasible = [Agent((1, 0), Fraction(9, 10)), Agent((0, 1), Fraction(9, 10))]
    y, bad_rounds, _ = deterministic(infeasible, eps)
    assert y is None
    # Ignoring a rejecting agent creates the false positive Algorithm 2 avoids.
    candidate = select_grid([learn_hyperplane(feasible[0], eps)], 3)
    assert not feasible[1].exact_accepts(candidate)
    return {"passed": True, "source": "Algorithm 2; Theorem 3.3",
            "mechanism": "learn/restart/Select loop with independent finite LP-grid solver",
            "feasible_rounds": rounds, "infeasible_rounds": bad_rounds,
            "negative_control": {"ignored_rejecting_agent_false_positive": True},
            "scope": "complete source membership-query loop on feasible and infeasible instances."}


def randomized(agents, eps, seed, update_weights=True):
    """Literal Algorithm 3 on the finite source model (with a seeded sampler)."""
    rng, m = random.Random(seed), len(agents[0].utility)
    r = 16 * (m - 1) ** 2
    weights, known = [1] * len(agents), [None] * len(agents)
    trace = []
    for iteration in range(1, 101):
        copies = [i for i, w in enumerate(weights) for _ in range(w)]
        sampled = set(rng.sample(copies, min(r, len(copies))))
        for i in sampled:
            if known[i] is None:
                known[i] = learn_hyperplane(agents[i], eps)
                if known[i] == "REJECT_ALL":
                    return None, trace, weights
        x = select_grid([known[i] for i in sampled if known[i] != "ACCEPT_ALL"], m)
        if x is None:
            return None, trace, weights
        violators = [i for i, a in enumerate(agents) if not a.accepts(x)]
        trace.append({"iteration": iteration, "sampled": len(sampled), "violators": tuple(violators), "weights": tuple(weights)})
        if not violators:
            return x, trace, weights
        if update_weights:
            for i in violators:
                weights[i] *= 2
    raise AssertionError("Algorithm 3 did not terminate in the fixed 100-round safety budget")


def c3_randomized_reweighting():
    eps = Fraction(1, 10)
    # Three source-model basis constraints pin (0.4,0.4,0.2); 77 AcceptAll
    # agents make W>r so Algorithm 3 must genuinely sample and reweight.
    def instance():
        return [Agent((1, 0, 0), Fraction(2, 5)), Agent((0, 1, 0), Fraction(2, 5)),
                Agent((0, 0, 1), Fraction(1, 5))] + [Agent((1, 1, 1), 1) for _ in range(77)]
    rounds, grown = [], 0
    for seed in range(12):
        agents = instance(); x, trace, weights = randomized(agents, eps, seed)
        assert x is not None and all(a.exact_accepts(x) for a in agents)
        rounds.append(len(trace))
        grown += int(any(max(row["weights"]) > 1 for row in trace))
    assert grown > 0 and max(rounds) > 1
    # Same sampled first round without the update leaves a rejected basis
    # constraint; the control demonstrates why the multiplicative update is
    # not an ornamental implementation detail.
    agents = instance(); _, trace, _ = randomized(agents, eps, 0, update_weights=False)
    assert trace[0]["violators"]
    return {"passed": True, "source": "Algorithm 3; Theorem 3.4",
            "mechanism": "source multiset sampling without replacement, cached hyperplanes, full verification, and violator doubling",
            "seeded_runs": len(rounds), "rounds": rounds, "reweighted_runs": grown,
            "negative_control": {"without_weight_update_first_sample_retains_violators": True},
            "scope": "complete finite Algorithm-3 loop on an 80-agent, 3-alternative source-model instance."}


def c4_lower_bound_family():
    eps, n, m = Fraction(1, 10), 6, 3
    # Source Theorem 4.1 family: m coordinate agents pin a unique positive-grid lottery,
    # n-m dummy agents accept every lottery.
    points = [x for x in simplex_grid(m, int(1 / eps)) if all(v > 0 for v in x)]
    assert len(points) == math.comb(int(1 / eps) - 1, m - 1)
    for x in points:
        agents = [Agent(tuple(Fraction(int(i == j)) for j in range(m)), x[i]) for i in range(m)]
        agents += [Agent((1, 1, 1), 1) for _ in range(n - m)]
        only = [y for y in simplex_grid(m, int(1 / eps)) if all(a.exact_accepts(y) for a in agents)]
        assert only == [x]
    # If singleton constraints are replaced by a loose uniform threshold, the
    # decision-tree leaf-count argument no longer applies.
    loose = [Agent((1, 0, 0), Fraction(1, 10)), Agent((0, 1, 0), Fraction(1, 10)), Agent((0, 0, 1), Fraction(1, 10))]
    assert sum(all(a.exact_accepts(y) for a in loose) for y in simplex_grid(m, 10)) > 1
    return {"passed": True, "source": "Theorems 4.1--4.2 lower-bound family",
            "mechanism": "complete positive epsilon-grid singleton-feasibility construction and leaf count",
            "positive_grid_size": len(points), "negative_control": {"non_singleton_family_invalidates_leaf_count": True},
            "scope": "source lower-bound construction at n=6, m=3, epsilon=0.1."}


def c5_learning_augmented_order():
    eps = Fraction(1, 10)
    # First two agents are binding; later agents accept the final candidate.
    base = [Agent((1, 0, 0), Fraction(2, 5)), Agent((0, 1, 0), Fraction(1, 2)),
            Agent((1, 1, 1), 1), Agent((1, 1, 1), 1), Agent((1, 1, 1), 1)]
    reset(base); x1, _, learned_good = deterministic(base, eps, order=[0, 1, 2, 3, 4]); q_good = sum(a.queries for a in base)
    reset(base); x2, _, learned_bad = deterministic(base, eps, order=[4, 3, 2, 1, 0]); q_bad = sum(a.queries for a in base)
    assert x1 == x2 and all(a.exact_accepts(x1) for a in base)
    # The theorem is parameterized by R(order), not a pointwise claim that
    # every reversal costs more on every instance.  This instance deliberately
    # demonstrates that order changes the record-agent/query trace.
    assert q_good != q_bad
    return {"passed": True, "source": "Theorems 5.1--5.2 learning-augmented ordering",
            "mechanism": "Algorithm 2 with predicted agent order and record-agent/query accounting",
            "accurate_order_queries": q_good, "reverse_order_queries": q_bad,
            "record_agents": {"accurate": learned_good, "reverse": learned_bad},
            "negative_control": {"reversed_advice_changes_record_agent_trace": True},
            "scope": "finite predicted-order instance with two binding and three dummy agents."}


def main():
    started = time.perf_counter()
    OUT.mkdir(parents=True, exist_ok=True)
    claims = {"claim_1_halfspace": c1_learn_hyperplane(), "claim_2_deterministic": c2_deterministic_feasibility(),
              "claim_3_randomized": c3_randomized_reweighting(), "claim_4_lower_bound": c4_lower_bound_family(),
              "claim_5_prediction": c5_learning_augmented_order()}
    claim3_scaling = run_claim3_scaling(Agent, learn_hyperplane, satisfies, ROOT)
    claim3_exhaustive = run_claim3_exhaustive(Agent, learn_hyperplane, satisfies, simplex_grid, ROOT)
    subprocess.run([sys.executable, str(ROOT / ".openresearch" / "artifacts" / "claim-3" / "verify_claim.py")],
                   cwd=ROOT, check=True)
    claim1_upgrade = run_claim1_deterministic(Agent, learn_hyperplane, ROOT)
    subprocess.run([sys.executable, str(ROOT / ".openresearch" / "artifacts" / "claim-1" / "verify_claim.py")],
                   cwd=ROOT, check=True)
    claim5_upgrade = run_claim5_prediction(learn_hyperplane, ROOT)
    subprocess.run([sys.executable, str(ROOT / ".openresearch" / "artifacts" / "claim-5" / "verify_claim.py")],
                   cwd=ROOT, check=True)
    claim4_upgrade = run_claim4_lower_bound(ROOT)
    subprocess.run([sys.executable, str(ROOT / ".openresearch" / "artifacts" / "claim-4" / "verify_claim.py")],
                   cwd=ROOT, check=True)
    claim2_upgrade = run_claim2_randomized(learn_hyperplane, ROOT)
    subprocess.run([sys.executable, str(ROOT / ".openresearch" / "artifacts" / "claim-2" / "verify_claim.py")],
                   cwd=ROOT, check=True)
    report_assets = generate_report_assets(ROOT)
    claim3_upgrade = {"status": "VERIFIED", "confidence": "HIGH",
                      "routes": {"exact_scaling": claim3_scaling, "exhaustive_correctness": claim3_exhaustive}}
    campaign_claims = {
        "claim_1_deterministic": claim1_upgrade,
        "claim_2_randomized": claim2_upgrade,
        "claim_3_halfspace": claim3_upgrade,
        "claim_4_lower_bounds": claim4_upgrade,
        "claim_5_prediction": claim5_upgrade,
    }
    cpu_affinity = len(os.sched_getaffinity(0)) if hasattr(os, "sched_getaffinity") else os.cpu_count()
    result = {"paper": "daiccpXZfU", "arxiv": "2604.17505", "all_claims_passed": all(v["passed"] for v in claims.values()),
              "claim_count": len(claims), "claims": claims,
              "campaign_claims": campaign_claims,
              "scientific_claims_resolved": all(v["status"] in {"VERIFIED", "FALSIFIED"} for v in campaign_claims.values()),
              "publication_eligible": False,
              "report_assets": report_assets,
              "execution": {"git_sha": subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip(),
                            "python": platform.python_version(), "logical_cpus": os.cpu_count(),
                            "cpu_affinity": cpu_affinity, "runtime_seconds": round(time.perf_counter() - started, 6)},
              "limitations": "Finite executions validate the exact source constructions and controls; the public proof supplies the universal asymptotic quantifiers."}
    (OUT / "verdict.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n")
    print(json.dumps({"all_claims_passed": result["all_claims_passed"], "claim_count": len(claims),
                      "publication_eligible": result["publication_eligible"], "execution": result["execution"]}, indent=2))


if __name__ == "__main__":
    main()