#!/usr/bin/env python3 """Bounded solver-only retry for frozen rational-oracle LP cases. The input is never modified. No oracle parameters, candidate selections or budgets are changed. The alternate SciPy/HiGHS method is patched only in this process, leaving the frozen phase-two sources and original failures intact. """ from __future__ import annotations import argparse from collections import defaultdict from fractions import Fraction import hashlib import json import math from pathlib import Path import time import policy_lp from policy_lp import Oracle, atomic_json, direct_aggregate_transition, schedule_baselines from search_witnesses import evaluate_case def fixed_schedule_fallback(witness, oracle, K, config): """Export a feasible upper policy and reused test, without an LP claim.""" source_cases = [case for case in witness["cases"] if case["K"] < K and "terminal_test" in case] if not source_cases: raise ValueError("Fallback requires a terminal test from an earlier K") source = max(source_cases, key=lambda case: case["K"]) n, tau = witness["n"], float(Fraction(witness["tau"])) baselines = schedule_baselines(oracle, n, K, tau) chosen = baselines["best_fixed_completion_grid"] completions = chosen["cumulative_completions"] mass = {(0, 0, 0): 1.0} policy = [] completed = 0 for t in range(K): if t == 0: action = (0, 0, n) else: action = (completions[t - 1] - completed, 0, 0) completed = completions[t - 1] following = defaultdict(float) for state, probability in sorted(mass.items()): policy.append({"round": t + 1, "state_c_m_o": list(state), "state_occupancy": probability, "actions": [{"u_v_b": list(action), "probability": 1.0}]}) for destination, transition_probability in direct_aggregate_transition( oracle, state, action).items(): following[destination] += probability * transition_probability mass = dict(following) terminal = [mass.get((n, m, 0), 0.0) for m in range(n + 1)] target = [math.comb(n, m) * tau**m * (1 - tau)**(n - m) for m in range(n + 1)] upper_float = math.fsum(abs(q - p) for q, p in zip(terminal, target)) / 2 if abs(upper_float - chosen["tv"]) > 2e-10: raise AssertionError("Explicit fallback policy disagrees with fixed-grid baseline") return { "K": K, "lp_optimum": None, "terminal_test": list(source["terminal_test"]), "terminal_law": terminal, "policy": policy, "baselines": baselines, "policy_missing_state_rule": "(0,0,0) before final round; (o,n-c-o,0) in final round", "fallback": {"type": "reused terminal test and best fixed-grid feasible schedule", "source_terminal_test_K": source["K"], "source_witness_id": witness["id"], "cumulative_completions": completions, "policy_tv_float": upper_float, "scope": "No LP optimality claim; independent certificate establishes bracket"}, "diagnostics": {"certificate_type": "floating feasible-policy check, not yet certified", "terminal_mass_residual": abs(math.fsum(terminal) - 1), "objective_recomputed_from_terminal": upper_float}, } def run(args): input_bytes = args.input.read_bytes() payload = json.loads(input_bytes) config = json.loads(args.config.read_text()) # evaluate_case additionally caps each solve at 120 seconds and 250k # state-action variables. The underlying frozen solver sets threads=1. config["time_limit_seconds"] = min(120.0, args.time_limit) if config["time_limit_seconds"] <= 0: raise ValueError("time limit must be positive") if not 2 <= args.K <= 8: raise ValueError("K must lie between 2 and 8") if args.input.resolve() == args.output.resolve(): raise ValueError("Use a separate output path; original evidence must be preserved") if isinstance(payload, dict) and "witnesses" in payload: witnesses = payload["witnesses"] elif isinstance(payload, dict) and "id" in payload and "cases" in payload: witnesses = [payload] else: raise ValueError("Expected one candidate object or a witnesses object") original_linprog = policy_lp.linprog def retry_linprog(*positional, **keywords): keywords["method"] = args.method options = dict(keywords.get("options", {})) options.update(threads=1, time_limit=config["time_limit_seconds"]) keywords["options"] = options return original_linprog(*positional, **keywords) policy_lp.linprog = retry_linprog started = time.perf_counter() source_sha = hashlib.sha256(input_bytes).hexdigest() source_config_sha = hashlib.sha256(args.config.read_bytes()).hexdigest() provenance = { "scope": "Solver-only retry; exact oracle, n, budget and head bound frozen", "input_path": str(args.input.resolve()), "input_sha256": source_sha, "config_path": str(args.config.resolve()), "config_sha256": source_config_sha, "method": args.method, "K": args.K, "solver_time_limit_seconds": config["time_limit_seconds"], "threads": 1, "started_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), "status": "running", "attempts": [], "errors": [], } payload["retry_metadata"] = provenance args.output.parent.mkdir(parents=True, exist_ok=True) atomic_json(args.output, payload) try: for witness in witnesses: attempt_start = time.perf_counter() frozen_keys = ("id", "n", "tau", "weights", "probabilities", "budget", "head_bound") frozen = {key: witness[key] for key in frozen_keys} frozen_sha = hashlib.sha256(json.dumps(frozen, sort_keys=True).encode()).hexdigest() record = {"id": witness["id"], "n": witness["n"], "K": args.K, "method": args.method, "frozen_parameters_sha256": frozen_sha} if any(case["K"] == args.K for case in witness["cases"]): record["status"] = "skipped_existing_case" provenance["attempts"].append(record) print(f"SKIP {witness['id']} K={args.K}: existing case preserved", flush=True) atomic_json(args.output, payload) continue try: if Fraction(witness["tau"]) != Fraction(str(config["tau"])): raise ValueError("Witness tau and supplied frozen config disagree") oracle = Oracle(tuple(float(Fraction(x)) for x in witness["probabilities"]), tuple(float(Fraction(x)) for x in witness["weights"])) if args.method == "bellman-fixed-schedule": case = fixed_schedule_fallback(witness, oracle, args.K, config) else: case = evaluate_case(oracle, int(witness["n"]), args.K, config, literal=False, baselines=True) monotonic_checks = [] for previous in witness["cases"]: if case["lp_optimum"] is None or previous.get("lp_optimum") is None: continue signed_difference = (case["lp_optimum"] - previous["lp_optimum"] if previous["K"] < args.K else previous["lp_optimum"] - case["lp_optimum"]) monotonic_checks.append({"other_K": previous["K"], "monotonic_violation": max(0.0, signed_difference)}) if signed_difference > 2e-7: raise AssertionError("Fixed-oracle optimal TV is not monotone across K") case["retry_provenance"] = { "method": args.method, "source_input_sha256": source_sha, "frozen_parameters_sha256": frozen_sha, "solver_time_limit_seconds": config["time_limit_seconds"], "monotonic_checks": monotonic_checks, } witness["cases"].append(case) witness["cases"].sort(key=lambda item: item["K"]) if {key: witness[key] for key in frozen_keys} != frozen: raise AssertionError("Frozen witness parameters changed") record.update(status="complete", lp_optimum=case["lp_optimum"], wall_seconds=time.perf_counter() - attempt_start) print(f"RETRY PASS {witness['id']} K={args.K} method={args.method}: " f"LP_TV={case['lp_optimum']}", flush=True) except (RuntimeError, ArithmeticError, AssertionError, MemoryError, ValueError) as exc: record.update(status="failed", error=str(exc), wall_seconds=time.perf_counter() - attempt_start) provenance["errors"].append(dict(record)) print(f"RETRY FAILED {witness['id']} K={args.K}: {exc}", flush=True) provenance["attempts"].append(record) atomic_json(args.output, payload) finally: policy_lp.linprog = original_linprog provenance.update(status="complete" if not provenance["errors"] else "complete_with_errors", elapsed_seconds=time.perf_counter() - started, finished_utc=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())) atomic_json(args.output, payload) return not provenance["errors"] if __name__ == "__main__": parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--config", required=True, type=Path) parser.add_argument("--input", required=True, type=Path) parser.add_argument("--output", required=True, type=Path) parser.add_argument("--method", choices=["highs-ipm", "highs-ds", "highs", "bellman-fixed-schedule"], default="highs-ipm") parser.add_argument("--K", type=int, default=4) parser.add_argument("--time-limit", type=float, default=120) raise SystemExit(0 if run(parser.parse_args()) else 1)