From 4b99cd9ec797c7c6f5c5d436565af83c0b9233fc Mon Sep 17 00:00:00 2001 From: Wentao Li Date: Thu, 15 Oct 2026 09:09:18 +0000 Subject: [PATCH 1/2] Tooling: wire packed omission lanes into production R439 atlas Promote proved opt-in research/omission-lanes-seed92 (#1433) into research/r439-omission-atlas-seed81/verify.py with identical certificates, pin hygiene, and a production verification package. --- research/omission-lanes-production/NOTICE.md | 14 ++ research/omission-lanes-production/README.md | 82 +++++++ .../omission-lanes-production/SOURCES.json | 63 ++++++ research/omission-lanes-production/TASK.json | 70 ++++++ .../omission-lanes-production/VERIFY.json | 38 ++++ .../omission-lanes-production/baseline.py | 213 ++++++++++++++++++ .../omission-lanes-production/benchmark.py | 111 +++++++++ research/omission-lanes-production/verify.py | 206 +++++++++++++++++ research/omission-lanes-seed92/README.md | 4 + research/omission-lanes-seed92/RESULT.json | 10 +- research/omission-lanes-seed92/SOURCES.json | 10 +- research/omission-lanes-seed92/VERIFY.json | 2 +- research/omission-lanes-seed92/baseline.py | 213 ++++++++++++++++++ research/omission-lanes-seed92/replay.py | 83 ++++--- research/r439-omission-atlas-seed81/README.md | 5 + research/r439-omission-atlas-seed81/verify.py | 32 ++- .../r439-three-omission-distance/SOURCES.json | 10 +- .../r439-three-omission-distance/VERIFY.json | 3 +- 18 files changed, 1127 insertions(+), 42 deletions(-) create mode 100644 research/omission-lanes-production/NOTICE.md create mode 100644 research/omission-lanes-production/README.md create mode 100644 research/omission-lanes-production/SOURCES.json create mode 100644 research/omission-lanes-production/TASK.json create mode 100644 research/omission-lanes-production/VERIFY.json create mode 100644 research/omission-lanes-production/baseline.py create mode 100644 research/omission-lanes-production/benchmark.py create mode 100644 research/omission-lanes-production/verify.py create mode 100644 research/omission-lanes-seed92/baseline.py diff --git a/research/omission-lanes-production/NOTICE.md b/research/omission-lanes-production/NOTICE.md new file mode 100644 index 0000000000..d612800512 --- /dev/null +++ b/research/omission-lanes-production/NOTICE.md @@ -0,0 +1,14 @@ +# Notice + +This package wires Sagar Thakrar’s (@thakrarsagar) proved opt-in packed +literal omission lanes from `research/omission-lanes-seed92/` (incorporated +CrocSwap [#1433](https://github.com/CrocSwap/integer-mult-bounds/pull/1433)) +into the production R439 omission atlas +`research/r439-omission-atlas-seed81/verify.py`. + +Credit **woklerx** for the retained PR1017 / seed81 complete single-ADD +omission atlas, and **Sagar Thakrar** for the exact integer-lane packing. +Predecessor notices in the atlas and opt-in package remain intact. + +Prepared by Wentao Li (VictorLiwentao, https://x.com/Is__Victor) with substantial +AI assistance. Apache-2.0. diff --git a/research/omission-lanes-production/README.md b/research/omission-lanes-production/README.md new file mode 100644 index 0000000000..02601c549f --- /dev/null +++ b/research/omission-lanes-production/README.md @@ -0,0 +1,82 @@ +# Production packed lanes for the R439 omission atlas + +**Tooling improvement; no new kappa.** At base +`0b1cccf86e2f5132ed286a26ef0a681a495740ea`, +`research/r439-omission-atlas-seed81/verify.py` still replayed every single-ADD +omission with a fresh 661-bit row map. Sagar Thakrar’s opt-in adapter +`research/omission-lanes-seed92/` (incorporated +[#1433](https://github.com/CrocSwap/integer-mult-bounds/pull/1433)) already +proved sixteen independent omissions in integer bit lanes with identical +complete certificates. This package wires that equivalent rewrite into the +**production** PR1017 atlas used by R439 omission tooling. + +The historical per-omission `replay(gates,k)` helper is retained for baseline +and witness checks. Dependent packages that live-pinned the pairwise-era atlas +digest are demoted or refreshed: opt-in `omission-lanes-seed92` vendors +pairwise `baseline.py`; `r439-three-omission-distance` demotes its atlas +`verify.py` pin to provenance (it has its own independent replay). + +## Reproduce + +Python **3.12**, standard library only, from the repository root: + +```sh +python3.12 -I -B research/omission-lanes-production/verify.py +python3.12 -I -O -B research/omission-lanes-production/verify.py +python3.12 -B scripts/research_package.py --package research/omission-lanes-production +taskset -c 0 python3.12 -I -B research/omission-lanes-production/benchmark.py --rounds 5 --write-result +``` + +Expected: + +```text +PASS_OMISSION_LANES_PRODUCTION honest=1 matrices=5563 short_checks=… corruption=1 certs=1 no_new_kappa +PASS_REGISTERED_RESEARCH_PACKAGE research/omission-lanes-production outcome=completed +PASS_IDENTICAL_OMISSION_LANES_PRODUCTION_RECEIPTS +``` + +Default verify is read-only. Temp-copy packed-mutant bit-flip foil rejects via +audit failure. Package gates under `-O` still load checkers with +`compile(..., optimize=0)`. Full `make verify`, selected cold replay, Lean, and +multiplication-theorem obligations were not rerun for this isolated +historical-checker change. + +## Result + +On Linux / CPython 3.12.3 with `taskset -c 0`, five alternating fresh-process +pairs over the complete 5,563-mutant atlas gave the median wall time recorded +in [`RESULT.json`](RESULT.json). Timing is host-descriptive and is not a +correctness gate. Every honest receipt matches +`research/r439-omission-atlas-seed81/CERTIFICATE.json`. + +## Why the packed lanes are equivalent + +Pack a batch of `B` omissions as width-`N` lanes inside one Python integer. +Lane `j` occupies bits `[jN, (j+1)N)`. An ADD is an XOR of source into +destination; XOR cannot carry across lanes. Suppressing lane `j` at omitted +gate `k` is exactly the historical `if k != omit` guard for that lane. See +`research/omission-lanes-seed92/`. + +## Open next questions + +- Should other historical copies of the same literal omission loop adopt packed + lanes with coordinated digest refresh? +- Should `research/omission-lanes-seed92` be marked superseded as an opt-in + monkey-patch now that production ships packed lanes? + +## Overlap and credit + +Closest priors (different delivery): + +- `research/omission-lanes-seed92/` / [#1433](https://github.com/CrocSwap/integer-mult-bounds/pull/1433) + — opt-in packed lanes; this is the production wiring. +- [CrocSwap/integer-mult-bounds#756](https://github.com/CrocSwap/integer-mult-bounds/pull/756) + — identical-receipt tooling quality bar. +- Leave-alone tooling through [#2412](https://github.com/CrocSwap/integer-mult-bounds/pull/2412) + and pending `cursor/scalar-fused-dyadic-production-60b9` / deferred + `cursor/ck-dyadic-replay-production-60b9` were not reopened. + +Credit woklerx and Sagar Thakrar. Prepared by Wentao Li +([VictorLiwentao](https://github.com/VictorLiwentao), +[Is__Victor](https://x.com/Is__Victor)) with substantial AI assistance. +Apache-2.0. diff --git a/research/omission-lanes-production/SOURCES.json b/research/omission-lanes-production/SOURCES.json new file mode 100644 index 0000000000..de463ffe73 --- /dev/null +++ b/research/omission-lanes-production/SOURCES.json @@ -0,0 +1,63 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1" + }, + { + "path": "research/r439-omission-atlas-seed81/verify.py", + "usage": "provenance", + "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", + "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", + "note": "Literal-era digest retained as provenance; working production file ships packed lanes (see OPTIMIZED digest in verify.py)." + }, + { + "path": "research/omission-lanes-production/baseline.py", + "usage": "input", + "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", + "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", + "note": "Vendored literal atlas for reference-engine comparisons." + }, + { + "path": "research/r439-omission-atlas-seed81/CERTIFICATE.json", + "usage": "input", + "sha256": "05c44b5d818862563a6674131024b1460d1e7bcb7828e4ebee4ec0198129e4e7", + "git_blob": "32cbc2379deea1ddf79feb05cb422da643e730b7" + }, + { + "path": "research/r439-omission-atlas-seed81/SOURCES.json", + "usage": "input", + "sha256": "6056be2b6fb0bc511bf215d658d440c7bf5cc9bd856eeff62c2361edb513989c", + "git_blob": "55517ccdcbca283bd7383b0fc651e3e7449b5991" + }, + { + "path": "research/r439-helper-stars-seed19/candidate.json.gz", + "usage": "input", + "sha256": "d8b08885e8ce9868200b2645189d15ed18a27fc2742e54990b3257a0ca4df6b8", + "git_blob": "8b0210d8b8e9524182e5f54f9bf93c28f4719735" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "input", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a" + }, + { + "path": "research/omission-lanes-seed92/replay.py", + "usage": "input", + "sha256": "9bfb3dfd186534467213c48c2ef88b226dc02aa6b8ab0312205b1b67a7ce928b", + "git_blob": "ef9456d16ff4930cfa0ed6dc338c8145c885c97a", + "note": "Live opt-in packed kernel (post production-wiring hygiene)." + } + ] +} diff --git a/research/omission-lanes-production/TASK.json b/research/omission-lanes-production/TASK.json new file mode 100644 index 0000000000..2fa890e20d --- /dev/null +++ b/research/omission-lanes-production/TASK.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "task_id": "replay-runtime", + "priority_revision": 4, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "chooser_seed": "omission-lanes-production-60b9", + "budget_minutes": 60, + "original_card": { + "id": "replay-runtime", + "question": "Can one measured replay bottleneck be sped up without dropping coverage?", + "starting_points": [ + "scripts/run_isolated_tests.py", + "scripts/verify_replay_coverage.py", + "certificates/selected-result.json" + ], + "methods": [ + "Profile one isolated replay and optimize the measured bottleneck.", + "Design source-bound reuse with explicit dependency invalidation and negative controls." + ], + "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the selected reproduction command and choose a single replay stage for profiling.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "allowed_variations": [ + "Profile one stage or design one source-bound cache boundary." + ], + "scope_change_triggers": [ + "Skipping coverage or comparing different fixtures to claim speedup." + ], + "overlap_terms": [ + "replay runtime", + "cache invalidation", + "isolated tests" + ] + }, + "scope_status": "refined", + "actual_scope": "Can the production R439 omission atlas research/r439-omission-atlas-seed81/verify.py adopt the proved exact packed integer-lane omission replays from research/omission-lanes-seed92/ (#1433) so that the shipped atlas is faster while every certificate field stays identical?", + "scope_change_reason": "The catalogue card asks for one measured replay bottleneck with before/after wall time and retained checks. Expertise override selected verifier-engineering after surveying leave-alone production rewrites through #2412, pending scalar-fused-dyadic production, and the deferred thin ck-dyadic production tip. Remaining proved opt-in adapter #1433 still left production atlas on per-omission literal replay; Linux host probe measured ~1.77× for the opt-in packing.", + "bottleneck_link": "Faster trustworthy PR1017 omission-atlas audits increase review throughput for R439 tooling without changing kappa or check coverage.", + "stop_rule": "Stop after wiring one production object with identical-receipt evidence, pin-drift demotions, and a descriptive before/after wall-time sample clearly above ~1.5×; do not invent kappa or reopen leave-alone objects.", + "evidence": "PASS_OMISSION_LANES_PRODUCTION via research/omission-lanes-production/verify.py (also under -O); PASS_REGISTERED_RESEARCH_PACKAGE; PASS_IDENTICAL_OMISSION_LANES_PRODUCTION_RECEIPTS via pinned-CPU benchmark.py --rounds 5; vendor baseline.py; demote live atlas pins in omission-lanes-seed92 and r439-three-omission-distance.", + "author": "Wentao Li", + "email": "wentaol4@illinois.edu", + "github": "VictorLiwentao", + "ai_assistance": "Substantial AI assistance for orientation, overlap search, profiling, production wiring, packaging, benchmarking and writing. Not independent human peer review.", + "outcome": "completed", + "open_questions": [ + { + "question": "Should other historical copies of the same literal omission loop adopt packed lanes with coordinated digest refresh?", + "why_it_matters": "Sibling research packages may still pay per-omission replay cost.", + "first_step": "Enumerate packages that call replay(gates,k) over the same 5563-gate domain.", + "blocked_by": "Maintainer inventory-refresh preference / one-object stop rule." + }, + { + "question": "Should research/omission-lanes-seed92 be marked superseded as an opt-in monkey-patch now that production ships packed lanes?", + "why_it_matters": "Maintainers may want one recommended path for the PR1017 atlas.", + "first_step": "Add a one-line pointer in that package README after this change merges.", + "blocked_by": "Documentation-only follow-up." + } + ] +} diff --git a/research/omission-lanes-production/VERIFY.json b/research/omission-lanes-production/VERIFY.json new file mode 100644 index 0000000000..8c78d5f946 --- /dev/null +++ b/research/omission-lanes-production/VERIFY.json @@ -0,0 +1,38 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/omission-lanes-production/baseline.py", + "research/r439-omission-atlas-seed81/verify.py", + "research/r439-omission-atlas-seed81/CERTIFICATE.json", + "research/r439-omission-atlas-seed81/SOURCES.json", + "research/r439-helper-stars-seed19/candidate.json.gz", + "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "research/omission-lanes-seed92/replay.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Exact baseline copy of the base-commit atlas; production equals the packed-lane transform; identical honest certificate and 5563 matrices; short-word/batch controls; temp-copy packed-mutant bit-flip corruption control; duplicate JSON-key check; read-only default verify." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Same equivalence and pin discipline under -O. Loaders use compile(..., optimize=0) so atlas need() admission stays enforced." + } + ] +} diff --git a/research/omission-lanes-production/baseline.py b/research/omission-lanes-production/baseline.py new file mode 100644 index 0000000000..759d18d73d --- /dev/null +++ b/research/omission-lanes-production/baseline.py @@ -0,0 +1,213 @@ +"""Independent complete PR967 single-ADD omission atlas. +No predecessor code imports. Prepared for @woklerx with substantial +OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from collections import Counter, defaultdict +import gzip +import hashlib +import json +from pathlib import Path + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +BASE='2921874911956718fcaaaf9396fe8267b3cfa9f0' +INPUTS=('research/r439-helper-stars-seed19/candidate.json.gz', + 'research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz') +N=661 + + +def need(ok,message): + if not ok:raise ValueError(message) + + +def canonical(value): + return json.dumps(value,sort_keys=True,separators=(',',':'),allow_nan=False).encode() + + +def load(raw): + def pairs(items): + result={} + for k,v in items: + need(k not in result,'duplicate JSON key') + result[k]=v + return result + def bad(value):raise ValueError('nonfinite JSON') + return json.loads(raw,object_pairs_hook=pairs,parse_constant=bad) + + +def load_inputs(): + manifest=load((HERE/'SOURCES.json').read_bytes()) + need(set(manifest)=={'base_commit','files'},'source manifest fields') + need(manifest['base_commit']==BASE and set(manifest['files'])==set(INPUTS),'source pin inventory') + words=[] + for name in INPUTS: + raw=(ROOT/name).read_bytes() + need(hashlib.sha256(raw).hexdigest()==manifest['files'][name],'source pin mismatch: '+name) + words.append(load(gzip.decompress(raw))) + candidate,selected=words + need(candidate['v']==111 and candidate['R']==439 and len(candidate['start'])==N,'word dimensions') + need(set(candidate)==set(selected),'word field inventory') + need(all(canonical(candidate[k])==canonical(selected[k]) for k in selected if k!='D'), + 'non-D source fields changed') + return words + + +def expand(word): + gates=[] + for record,(frame,d,sources) in enumerate(word['D']): + need(type(frame) is int and frame==0,'D frame') + need(type(d) is int and 0<=d>i&1] + + +def vector_run(gates,input_mask,omit=-1): + values=[bool(input_mask>>i&1) for i in range(N)] + for k,(d,s,_,__) in enumerate(gates): + if k!=omit:values[d]=values[d]!=values[s] + return sum(int(v)<>row&1 else 0),'literal omission delta disagrees at '+str(k)) + seen_target=bool(u&target) + region_counts[region(k)]['total']+=1 + region_counts[region(k)]['target_visible' if seen_target else 'target_invisible']+=1 + full_unique[u,v]+=1 + if seen_target:target_unique[u&target,v]+=1 + else:invisible.append(k) + if v.bit_count()%2==0:allones_blind.append(k) + digest.update(canonical([k,d,s,record,position,str(u),str(v)])+b'\n') + # A singleton input in v's support activates exactly u. Provide literal + # Boolean witnesses for every distinct invisible output/input pair. + witnesses=[] + distinct={} + for k in invisible: + u,v=atlas[k] + distinct.setdefault((u,v),k) + for (u,v),k in distinct.items(): + singleton=v&-v + before=vector_run(gates,singleton);after=vector_run(gates,singleton,k) + need(before^after==u and not u&target and bool(u&helper),'helper-only witness') + d,s,record,position=gates[k] + witnesses.append({'gate':k,'record':record,'source_position':position,'destination':d,'source':s, + 'input_register':singleton.bit_length()-1,'changed_output_registers':bits(u)}) + # A representative input-blind fault is also replayed as literal Booleans: + # all ones misses it, whereas a single selected input bit exposes it. + blind=allones_blind[0] + u,v=atlas[blind] + singleton=v&-v + allones=(1< tuple[float, bytes]: + start = time.perf_counter() + result = module.run() + elapsed = time.perf_counter() - start + module.need( + module.canonical(module.load(module.canonical(result))) + == module.canonical(module.load(CERTIFICATE.read_bytes())), + "certificate mismatch", + ) + return elapsed, module.canonical(result) + + +def main(argv=None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--rounds", type=int, default=5) + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args(argv) + + base_times = [] + prod_times = [] + for i in range(args.rounds): + order = ("baseline", "production") if i % 2 == 0 else ("production", "baseline") + receipts = {} + for engine in order: + path = BASELINE if engine == "baseline" else PRODUCTION + module = load_checker(f"{engine}_{i}", path) + dt, receipt = run_once(module) + receipts[engine] = receipt + if engine == "baseline": + base_times.append(dt) + else: + prod_times.append(dt) + if receipts["baseline"] != receipts["production"]: + raise SystemExit("PASS gate failed: receipts diverged during benchmark") + + base_med = statistics.median(base_times) + prod_med = statistics.median(prod_times) + ratio = base_med / prod_med if prod_med else float("inf") + result = { + "schema_version": 1, + "package": "research/omission-lanes-production", + "base_commit": BASE_COMMIT, + "workload": "complete R439 omission atlas (5563 literal single-ADD mutants)", + "rounds": args.rounds, + "baseline_seconds": base_times, + "production_seconds": prod_times, + "median_baseline_seconds": base_med, + "median_production_seconds": prod_med, + "median_speedup": ratio, + "baseline_sha256": hashlib.sha256(BASELINE.read_bytes()).hexdigest(), + "production_sha256": hashlib.sha256(PRODUCTION.read_bytes()).hexdigest(), + "python": sys.version, + "platform": os.uname().sysname + " " + os.uname().release, + "note": "Host-descriptive; not a correctness gate. Receipts identical each round.", + } + print( + json.dumps( + { + "median_baseline_seconds": base_med, + "median_production_seconds": prod_med, + "median_speedup": ratio, + }, + indent=2, + ), + flush=True, + ) + print( + "PASS_IDENTICAL_OMISSION_LANES_PRODUCTION_RECEIPTS " + f"rounds={args.rounds} median_speedup={ratio:.6f}", + flush=True, + ) + if args.write_result: + (PACKAGE / "RESULT.json").write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/research/omission-lanes-production/verify.py b/research/omission-lanes-production/verify.py new file mode 100644 index 0000000000..338af3bbef --- /dev/null +++ b/research/omission-lanes-production/verify.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Equivalence, pin and rejection controls for production packed omission atlas. + +Read-only by default. Timing is not a pass gate; see benchmark.py / RESULT.json. +Prepared by Wentao Li with substantial AI assistance. Apache-2.0. +""" +from __future__ import annotations + +import argparse +import hashlib +import io +import json +import random +import subprocess +import sys +import tempfile +import types +from contextlib import redirect_stdout +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +ATLAS = ROOT / "research/r439-omission-atlas-seed81" +PRODUCTION = ATLAS / "verify.py" +BASELINE = PACKAGE / "baseline.py" +CERTIFICATE = ATLAS / "CERTIFICATE.json" +OPT_IN_REPLAY = ROOT / "research/omission-lanes-seed92/replay.py" + +BASE_COMMIT = "0b1cccf86e2f5132ed286a26ef0a681a495740ea" +ORIGINAL_BLOB = "759d18d73dbab5d7620ce61395110aa57c06f901" +ORIGINAL_SHA256 = "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866" +OPTIMIZED_SHA256 = "6c3c94b01e3db5fb6d9e45eda4f60628252de1fab218e6e8233cc7949afd8966" +CERT_SHA256 = "05c44b5d818862563a6674131024b1460d1e7bcb7828e4ebee4ec0198129e4e7" + + +def require(condition, message): + if not condition: + raise AssertionError(message) + + +def digest_file(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def unique_object(pairs): + out = {} + for key, value in pairs: + require(key not in out, f"duplicate JSON key: {key}") + out[key] = value + return out + + +def load_checker(name: str, source: Path): + """Load atlas checker with assertions kept even when this wrapper runs under -O. + + `__file__` is always the live atlas path so HERE/SOURCES/CERTIFICATE resolve. + """ + module = types.ModuleType(name) + module.__file__ = str(PRODUCTION) + exec(compile(source.read_bytes(), str(PRODUCTION), "exec", optimize=0), module.__dict__) + return module + + +def check_baseline_bytes() -> None: + original = subprocess.check_output( + ["git", "show", f"{BASE_COMMIT}:research/r439-omission-atlas-seed81/verify.py"], + cwd=ROOT, + ) + require(hashlib.sha256(original).hexdigest() == ORIGINAL_SHA256, "base atlas sha256 drift") + blob = ( + subprocess.check_output( + ["git", "rev-parse", f"{BASE_COMMIT}:research/r439-omission-atlas-seed81/verify.py"], + cwd=ROOT, + ) + .decode() + .strip() + ) + require(blob == ORIGINAL_BLOB, "base atlas blob drift") + require(BASELINE.read_bytes() == original, "baseline.py must equal the base-commit atlas") + require(digest_file(PRODUCTION) == OPTIMIZED_SHA256, "production atlas digest drift") + require(PRODUCTION.read_bytes() != original, "production must differ from literal baseline") + require(digest_file(CERTIFICATE) == CERT_SHA256, "certificate digest drift") + require(OPT_IN_REPLAY.exists(), "opt-in packed replay missing") + prod_text = PRODUCTION.read_text(encoding="utf-8") + base_text = BASELINE.read_text(encoding="utf-8") + require("def packed_replays(" in prod_text, "production must define packed_replays") + require("mutants=packed_replays(gates,N)" in prod_text.replace(" ", ""), + "production must consume packed mutants") + require("def packed_replays(" not in base_text, "baseline must stay literal") + require("changed=replay(gates,k)" in base_text.replace(" ", ""), + "baseline must keep per-omission replay") + + +def outcome(module) -> tuple: + printed = io.StringIO() + try: + with redirect_stdout(printed): + result = module.run() + # Match CLI certificate binding without writing. + module.need( + module.canonical(module.load(module.canonical(result))) + == module.canonical(module.load(CERTIFICATE.read_bytes())), + "certificate mismatch", + ) + except Exception as exc: # noqa: BLE001 - compare exact failure class/message + return ("raise", type(exc).__name__, str(exc)) + return ("pass", module.canonical(result), printed.getvalue()) + + +def check_identical_receipts() -> dict: + ref = load_checker("omission_baseline", BASELINE) + prod = load_checker("omission_production", PRODUCTION) + left = outcome(ref) + right = outcome(prod) + require(left == right, "honest mismatch on R439 omission atlas") + require(left[0] == "pass", "honest atlas must pass") + expected = ref.canonical(ref.load(CERTIFICATE.read_bytes())) + require(left[1] == expected, "honest receipt must match CERTIFICATE.json") + + # Independent packed/literal matrix stream agreement (same as opt-in). + gates = ref.expand(ref.load_inputs()[0]) + count = 0 + for k, actual in enumerate(prod.packed_replays(gates, ref.N)): + expected_rows = ref.replay(gates, k) + require(actual == expected_rows, f"full literal matrix mismatch: {k}") + count += 1 + require(count == 5563, "full literal omission coverage") + + # Seeded short-word / batch-boundary agreement. + rng = random.Random(92) + edges = [(d, s, 0, 0) for d in range(3) for s in range(3) if d != s] + from itertools import product + + words = [word for length in range(5) for word in product(edges, repeat=length)] + words += [ + tuple(rng.choice(edges) for _ in range(length)) + for length in (15, 16, 17, 31, 32, 33, 63, 64, 65) + ] + short_ok = 0 + for word in words: + expected_maps = [ref.replay(word, k)[:3] for k in range(len(word))] + for size in (1, 2, 3, 16, 64): + require( + list(prod.packed_replays(word, 3, size)) == expected_maps, + "short-word or batch-boundary mismatch", + ) + short_ok += 1 + return {"honest": 1, "matrices": count, "short_checks": short_ok} + + +def check_temp_corruption_rejection() -> dict: + """On-disk foil that flips one packed mutant bit must reject closed.""" + text = PRODUCTION.read_text(encoding="utf-8") + needle = "changed=next(mutants,None)" + require(needle in text, "packed mutant site missing for corruption control") + foil = ( + "changed=next(mutants,None)\n" + " if changed is not None and k==16:\n" + " changed=list(changed);changed[-1]^=1<<(N-1)\n" + ) + foil_text = text.replace(needle + "\n", foil, 1) + require(foil_text != text, "mutant must differ on disk") + with tempfile.TemporaryDirectory(prefix="omission-lanes-prod-foil-") as tmp: + mutant_path = Path(tmp) / "verify.py" + mutant_path.write_text(foil_text, encoding="utf-8") + # Point HERE at atlas via __file__, but execute foil bytes. + module = types.ModuleType("omission_foil") + module.__file__ = str(PRODUCTION) + exec(compile(mutant_path.read_bytes(), str(PRODUCTION), "exec", optimize=0), module.__dict__) + printed = io.StringIO() + try: + with redirect_stdout(printed): + module.run() + raise AssertionError("corruption accepted") + except ValueError as exc: + require( + "literal omission delta disagrees at 16" in str(exc), + f"wrong rejection: {exc}", + ) + return {"corruption": 1} + + +def check_duplicate_json_keys() -> None: + raw = CERTIFICATE.read_bytes() + json.loads(raw, object_pairs_hook=unique_object) + + +def main(argv=None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.parse_args(argv) + check_baseline_bytes() + receipts = check_identical_receipts() + corruption = check_temp_corruption_rejection() + check_duplicate_json_keys() + print( + "PASS_OMISSION_LANES_PRODUCTION " + f"honest={receipts['honest']} matrices={receipts['matrices']} " + f"short_checks={receipts['short_checks']} " + f"corruption={corruption['corruption']} certs=1 no_new_kappa", + flush=True, + ) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/research/omission-lanes-seed92/README.md b/research/omission-lanes-seed92/README.md index 8b292e814f..215d8af58c 100644 --- a/research/omission-lanes-seed92/README.md +++ b/research/omission-lanes-seed92/README.md @@ -1,5 +1,9 @@ # Packed literal replay for the R439 omission atlas +**Production note:** `research/omission-lanes-production/` wires packed lanes into +production `research/r439-omission-atlas-seed81/verify.py`. This opt-in package +keeps a vendored literal `baseline.py` for reference-engine comparisons. + An opt-in acceleration of woklerx's retained [PR1017](https://github.com/CrocSwap/integer-mult-bounds/pull/1017) checker. Sixteen independent single-gate omissions run in integer bit lanes. All 5,563 mutant maps still propagate all 661 symbolic inputs through every diff --git a/research/omission-lanes-seed92/RESULT.json b/research/omission-lanes-seed92/RESULT.json index 4ee2711470..bf7a9c05a1 100644 --- a/research/omission-lanes-seed92/RESULT.json +++ b/research/omission-lanes-seed92/RESULT.json @@ -14,7 +14,7 @@ "extra omission map", "missing last partial-batch lane", "missing helper output row", - "pin research/r439-omission-atlas-seed81/verify.py", + "pin research/omission-lanes-seed92/baseline.py", "pin research/r439-omission-atlas-seed81/SOURCES.json", "pin research/r439-omission-atlas-seed81/CERTIFICATE.json", "pin research/r439-helper-stars-seed19/candidate.json.gz", @@ -33,7 +33,13 @@ "rows_per_matrix": 661, "scope": "Finite PR1017 omission replay only; no new kappa or full theorem proof.", "seed": 92, - "short_word_batch_sizes": [1, 2, 3, 16, 64], + "short_word_batch_sizes": [ + 1, + 2, + 3, + 16, + 64 + ], "short_words": 1564, "status": "PASS_PACKED_OMISSION_EQUIVALENCE" } diff --git a/research/omission-lanes-seed92/SOURCES.json b/research/omission-lanes-seed92/SOURCES.json index 7745ba5584..1d081f44fd 100644 --- a/research/omission-lanes-seed92/SOURCES.json +++ b/research/omission-lanes-seed92/SOURCES.json @@ -4,9 +4,17 @@ "files": [ { "path": "research/r439-omission-atlas-seed81/verify.py", + "usage": "provenance", + "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", + "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", + "note": "Literal-era digest retained as provenance after research/omission-lanes-production/; working atlas ships packed lanes. Reference engine uses vendored baseline.py." + }, + { + "path": "research/omission-lanes-seed92/baseline.py", "usage": "input", "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", - "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901" + "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", + "note": "Vendored literal atlas for reference-engine comparisons." }, { "path": "research/r439-omission-atlas-seed81/SOURCES.json", diff --git a/research/omission-lanes-seed92/VERIFY.json b/research/omission-lanes-seed92/VERIFY.json index 0a6c9d429e..ca5f71139d 100644 --- a/research/omission-lanes-seed92/VERIFY.json +++ b/research/omission-lanes-seed92/VERIFY.json @@ -4,7 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "research/r439-omission-atlas-seed81/verify.py", + "research/omission-lanes-seed92/baseline.py", "research/r439-omission-atlas-seed81/SOURCES.json", "research/r439-omission-atlas-seed81/CERTIFICATE.json", "research/r439-helper-stars-seed19/candidate.json.gz", diff --git a/research/omission-lanes-seed92/baseline.py b/research/omission-lanes-seed92/baseline.py new file mode 100644 index 0000000000..759d18d73d --- /dev/null +++ b/research/omission-lanes-seed92/baseline.py @@ -0,0 +1,213 @@ +"""Independent complete PR967 single-ADD omission atlas. +No predecessor code imports. Prepared for @woklerx with substantial +OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from collections import Counter, defaultdict +import gzip +import hashlib +import json +from pathlib import Path + +HERE=Path(__file__).resolve().parent +ROOT=HERE.parents[1] +BASE='2921874911956718fcaaaf9396fe8267b3cfa9f0' +INPUTS=('research/r439-helper-stars-seed19/candidate.json.gz', + 'research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz') +N=661 + + +def need(ok,message): + if not ok:raise ValueError(message) + + +def canonical(value): + return json.dumps(value,sort_keys=True,separators=(',',':'),allow_nan=False).encode() + + +def load(raw): + def pairs(items): + result={} + for k,v in items: + need(k not in result,'duplicate JSON key') + result[k]=v + return result + def bad(value):raise ValueError('nonfinite JSON') + return json.loads(raw,object_pairs_hook=pairs,parse_constant=bad) + + +def load_inputs(): + manifest=load((HERE/'SOURCES.json').read_bytes()) + need(set(manifest)=={'base_commit','files'},'source manifest fields') + need(manifest['base_commit']==BASE and set(manifest['files'])==set(INPUTS),'source pin inventory') + words=[] + for name in INPUTS: + raw=(ROOT/name).read_bytes() + need(hashlib.sha256(raw).hexdigest()==manifest['files'][name],'source pin mismatch: '+name) + words.append(load(gzip.decompress(raw))) + candidate,selected=words + need(candidate['v']==111 and candidate['R']==439 and len(candidate['start'])==N,'word dimensions') + need(set(candidate)==set(selected),'word field inventory') + need(all(canonical(candidate[k])==canonical(selected[k]) for k in selected if k!='D'), + 'non-D source fields changed') + return words + + +def expand(word): + gates=[] + for record,(frame,d,sources) in enumerate(word['D']): + need(type(frame) is int and frame==0,'D frame') + need(type(d) is int and 0<=d>i&1] + + +def vector_run(gates,input_mask,omit=-1): + values=[bool(input_mask>>i&1) for i in range(N)] + for k,(d,s,_,__) in enumerate(gates): + if k!=omit:values[d]=values[d]!=values[s] + return sum(int(v)<>row&1 else 0),'literal omission delta disagrees at '+str(k)) + seen_target=bool(u&target) + region_counts[region(k)]['total']+=1 + region_counts[region(k)]['target_visible' if seen_target else 'target_invisible']+=1 + full_unique[u,v]+=1 + if seen_target:target_unique[u&target,v]+=1 + else:invisible.append(k) + if v.bit_count()%2==0:allones_blind.append(k) + digest.update(canonical([k,d,s,record,position,str(u),str(v)])+b'\n') + # A singleton input in v's support activates exactly u. Provide literal + # Boolean witnesses for every distinct invisible output/input pair. + witnesses=[] + distinct={} + for k in invisible: + u,v=atlas[k] + distinct.setdefault((u,v),k) + for (u,v),k in distinct.items(): + singleton=v&-v + before=vector_run(gates,singleton);after=vector_run(gates,singleton,k) + need(before^after==u and not u&target and bool(u&helper),'helper-only witness') + d,s,record,position=gates[k] + witnesses.append({'gate':k,'record':record,'source_position':position,'destination':d,'source':s, + 'input_register':singleton.bit_length()-1,'changed_output_registers':bits(u)}) + # A representative input-blind fault is also replayed as literal Booleans: + # all ones misses it, whereas a single selected input bit exposes it. + blind=allones_blind[0] + u,v=atlas[blind] + singleton=v&-v + allones=(1< 0, 'positive width required') - require(type(batch_size) is int and batch_size > 0, 'positive batch size required') + require(type(width) is int and width > 0, "positive width required") + require(type(batch_size) is int and batch_size > 0, "positive batch size required") mask = (1 << width) - 1 for start in range(0, len(gates), batch_size): stop = min(start + batch_size, len(gates)) @@ -41,48 +48,64 @@ def packed_replays(gates, width, batch_size=BATCH_SIZE): def load_checker(packed=True): - pins = json.loads((HERE / 'SOURCES.json').read_text(encoding='utf-8')) - source = None - for pin in pins['files']: - if pin['usage'] != 'input': + pins = json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8")) + for pin in pins["files"]: + usage = pin.get("usage", "input") + if usage == "provenance": continue - relative = pin['path'] + relative = pin["path"] raw = (ROOT / relative).read_bytes() - require(sha256(raw).hexdigest() == pin['sha256'], 'source pin mismatch: ' + relative) - if relative == SOURCE: - source = raw.decode('utf-8') - require(source is not None, 'missing checker source pin') + require(sha256(raw).hexdigest() == pin["sha256"], "source pin mismatch: " + relative) + require(sha256(BASELINE.read_bytes()).hexdigest() == + "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", + "vendored baseline drift") + if packed: + # Prefer production packed atlas when present; otherwise patch baseline. + production_text = PRODUCTION.read_text(encoding="utf-8") + if "def packed_replays(" in production_text: + module = ModuleType("omission_atlas") + module.__file__ = str(PRODUCTION) + module.packed_replays = packed_replays + exec(compile(PRODUCTION.read_bytes(), module.__file__, "exec"), module.__dict__) + return module + source = BASELINE.read_text(encoding="utf-8") replacements = ( - (' atlas=factors(gates)\n', - ' atlas=factors(gates)\n mutants=packed_replays(gates,N)\n'), - (' changed=replay(gates,k)\n', - ' changed=next(mutants,None)\n' - ' need(changed is not None,"missing literal omission replay")\n' - ' need(len(changed)==N,"literal omission row coverage")\n'), - (' # A singleton input in v\'s support activates exactly u.', - ' need(next(mutants,None) is None,"extra literal omission replay")\n' - ' # A singleton input in v\'s support activates exactly u.'), + (" atlas=factors(gates)\n", + " atlas=factors(gates)\n mutants=packed_replays(gates,N)\n"), + (" changed=replay(gates,k)\n", + " changed=next(mutants,None)\n" + " need(changed is not None,\"missing literal omission replay\")\n" + " need(len(changed)==N,\"literal omission row coverage\")\n"), + (" # A singleton input in v's support activates exactly u.", + " need(next(mutants,None) is None,\"extra literal omission replay\")\n" + " # A singleton input in v's support activates exactly u."), ) for before, after in replacements: - require(source.count(before) == 1, 'pinned replay integration changed') + require(source.count(before) == 1, "pinned replay integration changed") source = source.replace(before, after) - module = ModuleType('omission_atlas') - module.__file__ = str(ROOT / SOURCE) + module = ModuleType("omission_atlas") + module.__file__ = str(PRODUCTION) + module.packed_replays = packed_replays + exec(compile(source, module.__file__, "exec"), module.__dict__) + return module + + module = ModuleType("omission_atlas") + module.__file__ = str(PRODUCTION) module.packed_replays = packed_replays - exec(compile(source, module.__file__, 'exec'), module.__dict__) + exec(compile(BASELINE.read_bytes(), module.__file__, "exec"), module.__dict__) return module def audit(packed=True): checker = load_checker(packed) result = checker.run() - expected = (checker.HERE / 'CERTIFICATE.json').read_bytes() + expected = (ATLAS / "CERTIFICATE.json").read_bytes() require(checker.canonical(result) == checker.canonical(checker.load(expected)), - 'complete predecessor certificate mismatch') + "complete predecessor certificate mismatch") return result -if __name__ == '__main__': +if __name__ == "__main__": audit() - print('PASS_PACKED_OMISSION_REPLAY gates=5563 columns=661 lanes=16 controls=7 no_new_kappa') + print("PASS_PACKED_OMISSION_REPLAY gates=5563 columns=661 lanes=16 controls=7 no_new_kappa") diff --git a/research/r439-omission-atlas-seed81/README.md b/research/r439-omission-atlas-seed81/README.md index 7a5feccdb3..8b87389449 100644 --- a/research/r439-omission-atlas-seed81/README.md +++ b/research/r439-omission-atlas-seed81/README.md @@ -1,5 +1,10 @@ # R439 complete single-ADD omission atlas +**Production note:** literal single-omission maps now use the packed integer-lane +replay from `research/omission-lanes-seed92/` / [#1433](https://github.com/CrocSwap/integer-mult-bounds/pull/1433) +(wired by `research/omission-lanes-production/`). Mathematical receipts are +unchanged. + **Finite independent verification; no new kappa.** In PR967's frozen 5,563-ADD D phase, every single elementary ADD omission changes the complete D boundary. All 5,563 resulting linear-map differences are distinct and have rank one. Observing only the 111 target outputs misses exactly **221 omissions**, all in the final helper-restoration region. Even observing every output on the single all-ones input misses **1,522 omissions**. This package supplies an exact fault-class census, all 221 concrete helper-only witnesses, and a practical independent replay. It does not propose a new circuit or improve the selected frontier. diff --git a/research/r439-omission-atlas-seed81/verify.py b/research/r439-omission-atlas-seed81/verify.py index 759d18d73d..00c655e44a 100644 --- a/research/r439-omission-atlas-seed81/verify.py +++ b/research/r439-omission-atlas-seed81/verify.py @@ -71,6 +71,29 @@ def replay(gates,omit=-1): return rows +def packed_replays(gates,width=N,batch_size=16): + """Yield every one-gate-omission map in chronological gate order. + + Sixteen independent omissions share one integer bit-lane batch. XOR cannot + carry across lanes, so each lane equals the historical per-omission replay. + Opt-in predecessor: research/omission-lanes-seed92/ (#1433). + """ + need(type(width) is int and width>0,'positive width required') + need(type(batch_size) is int and batch_size>0,'positive batch size required') + mask=(1<>(width*lane))&mask for row in rows] + + def factors(gates): # Forward row action obtains the covector immediately BEFORE each gate. rows=[1<>row&1 else 0),'literal omission delta disagrees at '+str(k)) seen_target=bool(u&target) @@ -144,6 +171,7 @@ def run(): else:invisible.append(k) if v.bit_count()%2==0:allones_blind.append(k) digest.update(canonical([k,d,s,record,position,str(u),str(v)])+b'\n') + need(next(mutants,None) is None,'extra literal omission replay') # A singleton input in v's support activates exactly u. Provide literal # Boolean witnesses for every distinct invisible output/input pair. witnesses=[] diff --git a/research/r439-three-omission-distance/SOURCES.json b/research/r439-three-omission-distance/SOURCES.json index ed0cb67f37..62ea857b05 100644 --- a/research/r439-three-omission-distance/SOURCES.json +++ b/research/r439-three-omission-distance/SOURCES.json @@ -23,14 +23,16 @@ { "path": "research/r439-omission-atlas-seed81/README.md", "usage": "input", - "git_blob": "7a5feccdb32ebc8441317b31b7bbdfa82862a7b6", - "sha256": "6fc756df2aa0afe5b63985c1a5b4878659a3387250092e9ae5167f3316d5de9f" + "git_blob": "8b8738944916ac50ac0c03e6b1552a9e0c0ec135", + "sha256": "812fabd455a7d1f77331e59d57150f28ff8ddc6ff47f9a54c5b24970f6dcc00a", + "note": "Refreshed after production packed-lanes README note; documentation pin only." }, { "path": "research/r439-omission-atlas-seed81/verify.py", - "usage": "input", + "usage": "provenance", "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", - "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866" + "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", + "note": "Literal-era digest retained as provenance after research/omission-lanes-production/; this package has its own independent replay and does not execute the atlas checker." } ] } diff --git a/research/r439-three-omission-distance/VERIFY.json b/research/r439-three-omission-distance/VERIFY.json index dc3d7ae00e..04860286f2 100644 --- a/research/r439-three-omission-distance/VERIFY.json +++ b/research/r439-three-omission-distance/VERIFY.json @@ -5,8 +5,7 @@ "requirements": [], "inputs": [ "research/r439-helper-stars-seed19/candidate.json.gz", - "research/r439-omission-atlas-seed81/README.md", - "research/r439-omission-atlas-seed81/verify.py" + "research/r439-omission-atlas-seed81/README.md" ], "commands": [ { From c36bb5355b97ee82bb2ee0f28b3214fa4583cafb Mon Sep 17 00:00:00 2001 From: Wentao Li Date: Thu, 15 Oct 2026 09:15:46 +0000 Subject: [PATCH 2/2] Evidence: record production packed-omission host benchmark and pin hygiene MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit RESULT.json median 1.69× on Linux/taskset-0; demote base-commit path pins for vendored baselines and atlas README; keep identical certificate digests. --- .../omission-lanes-production/RESULT.json | 29 +++++++++++++++++++ .../omission-lanes-production/SOURCES.json | 17 ++++------- research/omission-lanes-seed92/RESULT.json | 1 - research/omission-lanes-seed92/SOURCES.json | 9 +----- research/omission-lanes-seed92/VERIFY.json | 1 + .../r439-three-omission-distance/SOURCES.json | 8 ++--- .../r439-three-omission-distance/VERIFY.json | 3 +- 7 files changed, 41 insertions(+), 27 deletions(-) create mode 100644 research/omission-lanes-production/RESULT.json diff --git a/research/omission-lanes-production/RESULT.json b/research/omission-lanes-production/RESULT.json new file mode 100644 index 0000000000..cc2954bcbc --- /dev/null +++ b/research/omission-lanes-production/RESULT.json @@ -0,0 +1,29 @@ +{ + "schema_version": 1, + "package": "research/omission-lanes-production", + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "workload": "complete R439 omission atlas (5563 literal single-ADD mutants)", + "rounds": 5, + "baseline_seconds": [ + 3.7081245949998447, + 3.605200038999783, + 3.5811381710000205, + 3.6684772500000236, + 3.6298425279999265 + ], + "production_seconds": [ + 2.090888160999839, + 2.143346830000155, + 2.1176058920000287, + 2.166503299999931, + 2.1509510230000615 + ], + "median_baseline_seconds": 3.6298425279999265, + "median_production_seconds": 2.143346830000155, + "median_speedup": 1.6935395042899632, + "baseline_sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", + "production_sha256": "6c3c94b01e3db5fb6d9e45eda4f60628252de1fab218e6e8233cc7949afd8966", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux 6.12.94+", + "note": "Host-descriptive; not a correctness gate. Receipts identical each round." +} diff --git a/research/omission-lanes-production/SOURCES.json b/research/omission-lanes-production/SOURCES.json index de463ffe73..1555d97677 100644 --- a/research/omission-lanes-production/SOURCES.json +++ b/research/omission-lanes-production/SOURCES.json @@ -19,14 +19,7 @@ "usage": "provenance", "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", - "note": "Literal-era digest retained as provenance; working production file ships packed lanes (see OPTIMIZED digest in verify.py)." - }, - { - "path": "research/omission-lanes-production/baseline.py", - "usage": "input", - "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", - "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", - "note": "Vendored literal atlas for reference-engine comparisons." + "note": "Literal-era digest retained as provenance; working production file ships packed lanes (see OPTIMIZED digest in verify.py). Live equivalence uses package baseline.py plus working production path." }, { "path": "research/r439-omission-atlas-seed81/CERTIFICATE.json", @@ -54,10 +47,10 @@ }, { "path": "research/omission-lanes-seed92/replay.py", - "usage": "input", - "sha256": "9bfb3dfd186534467213c48c2ef88b226dc02aa6b8ab0312205b1b67a7ce928b", - "git_blob": "ef9456d16ff4930cfa0ed6dc338c8145c885c97a", - "note": "Live opt-in packed kernel (post production-wiring hygiene)." + "usage": "provenance", + "sha256": "041b36011d32d034843e279544336f696d39eaadab303cc386930db25d694024", + "git_blob": "851d9b715eb6b56a27a312ae0bb4129c3c9c4376", + "note": "Opt-in packed kernel at base_commit; working tree may carry production-wiring hygiene edits." } ] } diff --git a/research/omission-lanes-seed92/RESULT.json b/research/omission-lanes-seed92/RESULT.json index bf7a9c05a1..d3005274b9 100644 --- a/research/omission-lanes-seed92/RESULT.json +++ b/research/omission-lanes-seed92/RESULT.json @@ -14,7 +14,6 @@ "extra omission map", "missing last partial-batch lane", "missing helper output row", - "pin research/omission-lanes-seed92/baseline.py", "pin research/r439-omission-atlas-seed81/SOURCES.json", "pin research/r439-omission-atlas-seed81/CERTIFICATE.json", "pin research/r439-helper-stars-seed19/candidate.json.gz", diff --git a/research/omission-lanes-seed92/SOURCES.json b/research/omission-lanes-seed92/SOURCES.json index 1d081f44fd..cebe904f2e 100644 --- a/research/omission-lanes-seed92/SOURCES.json +++ b/research/omission-lanes-seed92/SOURCES.json @@ -7,14 +7,7 @@ "usage": "provenance", "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", - "note": "Literal-era digest retained as provenance after research/omission-lanes-production/; working atlas ships packed lanes. Reference engine uses vendored baseline.py." - }, - { - "path": "research/omission-lanes-seed92/baseline.py", - "usage": "input", - "sha256": "127d7679fb26e264018548a1301b2f0f437d834eb1f0ffa215556243077ff866", - "git_blob": "759d18d73dbab5d7620ce61395110aa57c06f901", - "note": "Vendored literal atlas for reference-engine comparisons." + "note": "Literal-era digest retained as provenance after research/omission-lanes-production/; working atlas ships packed lanes. Reference engine uses vendored baseline.py (checked in replay.py, not a base-commit path pin)." }, { "path": "research/r439-omission-atlas-seed81/SOURCES.json", diff --git a/research/omission-lanes-seed92/VERIFY.json b/research/omission-lanes-seed92/VERIFY.json index ca5f71139d..585480372e 100644 --- a/research/omission-lanes-seed92/VERIFY.json +++ b/research/omission-lanes-seed92/VERIFY.json @@ -5,6 +5,7 @@ "requirements": [], "inputs": [ "research/omission-lanes-seed92/baseline.py", + "research/omission-lanes-seed92/replay.py", "research/r439-omission-atlas-seed81/SOURCES.json", "research/r439-omission-atlas-seed81/CERTIFICATE.json", "research/r439-helper-stars-seed19/candidate.json.gz", diff --git a/research/r439-three-omission-distance/SOURCES.json b/research/r439-three-omission-distance/SOURCES.json index 62ea857b05..3d08d601b1 100644 --- a/research/r439-three-omission-distance/SOURCES.json +++ b/research/r439-three-omission-distance/SOURCES.json @@ -22,10 +22,10 @@ }, { "path": "research/r439-omission-atlas-seed81/README.md", - "usage": "input", - "git_blob": "8b8738944916ac50ac0c03e6b1552a9e0c0ec135", - "sha256": "812fabd455a7d1f77331e59d57150f28ff8ddc6ff47f9a54c5b24970f6dcc00a", - "note": "Refreshed after production packed-lanes README note; documentation pin only." + "usage": "provenance", + "git_blob": "7a5feccdb32ebc8441317b31b7bbdfa82862a7b6", + "sha256": "6fc756df2aa0afe5b63985c1a5b4878659a3387250092e9ae5167f3316d5de9f", + "note": "Atlas README at package base_commit; working tree may carry production packed-lanes note. This package does not execute the atlas checker." }, { "path": "research/r439-omission-atlas-seed81/verify.py", diff --git a/research/r439-three-omission-distance/VERIFY.json b/research/r439-three-omission-distance/VERIFY.json index 04860286f2..a07ba6cf7c 100644 --- a/research/r439-three-omission-distance/VERIFY.json +++ b/research/r439-three-omission-distance/VERIFY.json @@ -4,8 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "research/r439-helper-stars-seed19/candidate.json.gz", - "research/r439-omission-atlas-seed81/README.md" + "research/r439-helper-stars-seed19/candidate.json.gz" ], "commands": [ {