| |
| """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()) |
| |
| |
| 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) |
|
|
