#!/usr/bin/env python3 """D-cut CPU validation: arms A (brute-ref), B (ref-diverse), C (out-validators), D (trace-repair) — stubbed-LLM integration through handle_problem + harness tests. No GPU, no network. Exit 0 = all pass.""" import asyncio, importlib.util, json, os, subprocess, sys, tempfile from concurrent.futures import ThreadPoolExecutor HERE = os.path.dirname(os.path.abspath(__file__)) SELF = os.path.join(HERE, "minipatch", "selffb") sys.path.insert(0, SELF) spec = importlib.util.spec_from_file_location("svp", os.path.join(SELF, "selffb_v2_prepare.py")) mod = importlib.util.module_from_spec(spec) spec.loader.exec_module(mod) HARNESS_SPJ = os.path.join(HERE, "minipatch", "scripts", "lcb_public_probe_harness_spj.py") HARNESS_ORIG = os.path.join(HERE, "..", "round5_sv_cut", "minipatch", "scripts", "lcb_public_probe_harness_spj.py") RUN_INPUTS = os.path.join(SELF, "run_inputs_harness.py") PASS = FAIL = 0 def check(name, ok, detail=""): global PASS, FAIL ok = bool(ok); PASS += ok; FAIL += (not ok) print(f"{'PASS' if ok else 'FAIL'} {name}" + (f" [{detail}]" if detail and not ok else "")) # ── problems ───────────────────────────────────────────────────────────── P1 = ("Read two integers a and b from stdin and print their sum.\n\n" "Example\nInput\n1 2\nOutput\n3\n") P2 = ("Given n, print any pair of positive integers a b with a+b = n. " "If there are multiple valid answers, print any of them.\n\n" "Example\nInput\n4\nOutput\n1 3\n") SUM_CODE = "a,b=map(int,input().split());print(a+b)" BAD_EFF = "a,b=map(int,input().split());print(a-b)" # sample-gate fails DEVIANT = "a,b=map(int,input().split());print(a*b if a==b else a+b)" # sample-ok, deviates on 5 5 PAIR_OK = "n=int(input());print(1, n-1)" VALID_OVAL = ("import sys\n" "inp=open(sys.argv[1]).read().split();out=open(sys.argv[2]).read().split()\n" "n=int(inp[0])\n" "sys.exit(0 if len(out)==2 and all(t.lstrip('-').isdigit() for t in out)\n" " and int(out[0])>0 and int(out[1])>0 and int(out[0])+int(out[1])==n else 1)\n") BROKEN_OVAL = "import sys\nsys.exit(0)\n" # accepts everything class FakeMsg: pass class FakeClient: def __init__(self, sums=SUM_CODE, eff_b=SUM_CODE, oval=VALID_OVAL): self.n_reread = 0 self.sums, self.eff_b, self.oval = sums, eff_b, oval c = self class Completions: async def create(self, **kw): prompt = kw["messages"][0]["content"] txt = c.route(prompt) r = FakeMsg(); r.usage = FakeMsg() r.usage.prompt_tokens = 10; r.usage.completion_tokens = 10 ch = FakeMsg(); ch.message = FakeMsg(); ch.message.content = txt r.choices = [ch] return r self.chat = FakeMsg(); self.chat.completions = Completions() def route(self, p): py = lambda c: f"```python\n{c}\n```" if "Extract every SAMPLE" in p or "worked EXAMPLES" in p: smp = ({"input": "4\n", "output": "1 3\n"} if "pair" in p else {"input": "1 2\n", "output": "3\n"}) return f"```json\n{json.dumps({'samples': [smp]})}\n```" if "stress-input design" in p: probes = ["6\n"] if "pair" in p else ["0 0\n"] return (f"```json\n{json.dumps({'probe_inputs': [{'input': x} for x in probes]})}\n```" f"\n```python\nimport sys\nsys.exit(0)\n```") if "OUTPUT VALIDATOR program" in p: return py(self.oval) if "BRUTE-FORCE Python reference" in p: return py(self.sums) if "independent reading attempt" in p: self.n_reread += 1 return py(SUM_CODE if self.n_reread % 2 else DEVIANT) if "EFFICIENT, production-quality" in p: return py(PAIR_OK if "pair" in p else self.sums) if "name the algorithm" in p: return py(PAIR_OK if "pair" in p else self.eff_b) if "break_inputs" in p: return f"```json\n{json.dumps({'break_inputs': [{'input': '5 5\n'}, {'input': '9 1\n'}]})}\n```" # REF prompts and anything else: a correct solution return py(PAIR_OK if "pair" in p else SUM_CODE) def make_args(extra, tmp, loop_n=1): cap, orig_run, orig_ma = {}, mod.asyncio.run, mod.main_async mod.main_async = lambda a: cap.update(a=a) mod.asyncio.run = lambda c: c ck = os.path.join(tmp, "ck.json"); json.dump({"problems": []}, open(ck, "w")) sd = os.path.join(tmp, "seeds.jsonl"); open(sd, "w").write("") argv = ["p", "--checkpoint", ck, "--seeds", sd, "--loop", str(loop_n), "--out", os.path.join(tmp, "fb_tests.jsonl"), "--audit", os.path.join(tmp, "audit.jsonl"), "--bank", os.path.join(tmp, "bank.jsonl"), "--harness", RUN_INPUTS, "--agree", "all", "--samples", "anchor", "--gen-tests", "off", "--probes", "valid", "--wb-cands", "8", "--wb-certify", "--eff-anchor-tol", "0.7", "--exec-workers", "4", "--time-limit", "4.0"] + extra old = sys.argv; sys.argv = argv try: mod.main() finally: sys.argv = old; mod.asyncio.run = orig_run; mod.main_async = orig_ma a = cap["a"] a._trstreak_path = a.bank + ".trstreak.json" try: a._trstreak = json.load(open(a._trstreak_path)) except Exception: a._trstreak = {} return a def drive(args, pid, question, cands, client): async def go(): sem = asyncio.Semaphore(8) pool = ThreadPoolExecutor(max_workers=4) bank = mod.Bank(args.bank) lock = asyncio.Lock() outf = open(args.out, "a"); auditf = open(args.audit, "a") prob = {"question": question, "cands": cands} await mod.handle_problem(pid, prob, {"format": "stdin_stdout"}, client, args, sem, pool, bank, outf, auditf, lock) outf.close(); auditf.close(); pool.shutdown() asyncio.run(go()) audit = [json.loads(l) for l in open(args.audit)][-1] tests = {} for l in open(args.out): if l.strip() and not args.out.endswith("summary.jsonl"): r = json.loads(l) if "public_tests" in r: tests[r["id"]] = json.loads(r["public_tests"]) return audit, tests.get(pid) def run_harness(harness, code, tests): with tempfile.TemporaryDirectory() as td: cp = os.path.join(td, "c.py"); open(cp, "w").write(code) tp = os.path.join(td, "t.json"); json.dump(tests, open(tp, "w")) r = subprocess.run([sys.executable, harness, cp, tp], capture_output=True, text=True, timeout=120) return json.loads(r.stdout.strip().splitlines()[-1]) # ── T0: run_out_validator unit ─────────────────────────────────────────── check("T0a oval accepts valid", mod.run_out_validator(VALID_OVAL, "4\n", "2 2\n", 4.0) is True) check("T0b oval rejects invalid", mod.run_out_validator(VALID_OVAL, "4\n", "9 9\n", 4.0) is False) check("T0c oval crash = None", mod.run_out_validator("raise RuntimeError()", "4\n", "1 3\n", 4.0) in (False, None)) # ── T1-T3: harness property path ───────────────────────────────────────── tests_prop = {"inputs": ["4\n", "6\n"], "outputs": [None, None], "out_validators": [VALID_OVAL, VALID_OVAL], "time_limit": 4} v = run_harness(HARNESS_SPJ, "n=int(input());print(2, n-2)", tests_prop) check("T1 harness: alternate valid answer passes", v["category"] == "all_pass", str(v)[:120]) v = run_harness(HARNESS_SPJ, "n=int(input());print(9, 9)", tests_prop) check("T2 harness: invalid answer -> wrong_answer w/ property text", v["category"] == "wrong_answer" and "certified checker" in str(v.get("first_fail", {}).get("expected")), str(v)[:160]) tests_plain = {"inputs": ["1 2\n"], "outputs": ["3\n"], "time_limit": 4} v1 = run_harness(HARNESS_SPJ, SUM_CODE, tests_plain) v2 = run_harness(HARNESS_ORIG, SUM_CODE, tests_plain) check("T3 harness: bit-identical without field", v1 == v2, f"{v1} vs {v2}") # ── T4: arm A brute certification ──────────────────────────────────────── with tempfile.TemporaryDirectory() as tmp: a = make_args([], tmp) # sv7 control audit, t = drive(a, "p1", P1, [f"```python\n{SUM_CODE}\n```"], FakeClient(eff_b=BAD_EFF)) wb_out_ctrl = [o for i, o in zip(t["inputs"], t["outputs"]) if i.startswith("5 5")] ctrl_keys = set(audit["funnel"]) with tempfile.TemporaryDirectory() as tmp: a = make_args(["--brute-ref"], tmp) audit, t = drive(a, "p1", P1, [f"```python\n{SUM_CODE}\n```"], FakeClient(eff_b=BAD_EFF)) f = audit["funnel"] wb_out = [o for i, o in zip(t["inputs"], t["outputs"]) if i.startswith("5 5")] check("T4a brute validated", f.get("n_brute_valid") == 1, str(f)) check("T4b brute certifies wb label (1 eff + brute)", f.get("n_wb_cert_brute", 0) >= 1 and wb_out and wb_out[0] == "10", f"cert={f.get('n_wb_cert_brute')} out={wb_out}") check("T4c control stripped the same label", wb_out_ctrl and wb_out_ctrl[0] is None, str(wb_out_ctrl)) check("T4d control funnel has no D-cut keys", not (ctrl_keys & {"n_brute_valid", "n_wb_cert_brute", "oval_certified", "n_disputes", "trace_streak"}), str(ctrl_keys)) # ── T5: arm B dispute surfacing ────────────────────────────────────────── with tempfile.TemporaryDirectory() as tmp: a = make_args(["--ref-diverse", "2"], tmp) audit, t = drive(a, "p1", P1, [f"```python\n{SUM_CODE}\n```"], FakeClient()) f = audit["funnel"] srows = [json.loads(l) for l in open(a.out + ".summary.jsonl")] \ if os.path.exists(a.out + ".summary.jsonl") else [] check("T5a diverse refs sample-gated", f.get("n_diverse_valid", 0) >= 1, str(f)) check("T5b dispute detected + surfaced", f.get("n_disputes", 0) >= 1 and any("READING CHECK" in r["summary"] for r in srows), f"disputes={f.get('n_disputes')} rows={len(srows)}") # ── T6-T7: arm C property validators ───────────────────────────────────── with tempfile.TemporaryDirectory() as tmp: a = make_args(["--out-validators"], tmp) audit, t = drive(a, "p2", P2, [f"```python\n{PAIR_OK}\n```"], FakeClient()) f = audit["funnel"] check("T6a validator certified", f.get("oval_certified") is True, str(f)) check("T6b emission property-only", t and t.get("out_validators") and all(o is None for o in t["outputs"]), str(t)[:150]) with tempfile.TemporaryDirectory() as tmp: a = make_args(["--out-validators"], tmp) audit, t = drive(a, "p2", P2, [f"```python\n{PAIR_OK}\n```"], FakeClient(oval=BROKEN_OVAL)) check("T7 broken validator -> conservative skip", audit["funnel"].get("oval_certified") is False and audit.get("skip_prop") and not t, f"{audit.get('skip_prop')} t={bool(t)}") # ── T8: arm D trace-repair streak ──────────────────────────────────────── with tempfile.TemporaryDirectory() as tmp: a1 = make_args(["--trace-repair"], tmp, loop_n=1) bad = f"```python\n{BAD_EFF}\n```" audit1, _ = drive(a1, "p1", P1, [bad, bad], FakeClient()) s1 = os.path.exists(a1.out + ".summary.jsonl") a2 = make_args(["--trace-repair"], tmp, loop_n=2) audit2, _ = drive(a2, "p1", P1, [bad, bad], FakeClient()) srows = [json.loads(l) for l in open(a2.out + ".summary.jsonl")] \ if os.path.exists(a2.out + ".summary.jsonl") else [] check("T8a loop1: streak=1, no repair row yet", audit1["funnel"].get("trace_streak") == 1 and not s1, str(audit1["funnel"])) check("T8b loop2: streak=2 fires REPAIR MODE", audit2["funnel"].get("trace_streak") == 2 and any("REPAIR MODE" in r["summary"] for r in srows), f"{audit2['funnel'].get('trace_streak')} rows={len(srows)}") print(f"\n{PASS} passed, {FAIL} failed") sys.exit(1 if FAIL else 0)