From bb36fc65ee0b161229169505f4840c436c5ca2b9 Mon Sep 17 00:00:00 2001 From: Clear1nsight <22630354+Clear1nsight@users.noreply.github.com> Date: Wed, 11 Nov 2026 14:22:27 +1100 Subject: [PATCH 1/3] Reuse #7147 selected replay navigation for onboarding This is the exact documentation prerequisite retained by #7156. It points the onboarding check to the selected #7000/#7001 review. Credit to Rohan Arun and the source authors. --- docs/ci-verification.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 63ba3e9aa8..52b62d0481 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,8 +1,25 @@ # CI verification -## Current selected-family replay: #6030 +## Current selected-family replay: #7000 with #7001 The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json), +and [explicit source closure](../certificates/frontier7000-source.json). +`make frontier7000-verify` follows that exact-source selected replay. The review +reuses eleven authenticated preceding executions and records seven fresh serial +application, scalar and complete native-catalogue executions. The earlier +monolithic timeout is retained separately and is not completed coverage. +Consult the receipts for exact commands, source heads and limits. + +The five inherited framework assumptions remain. No complete uniform word, +literal multiplier execution, independent human proof or formal-kernel proof +is asserted. Routine research submissions do not need to rerun this +selected-family replay. The sections below preserve historical checkpoints. + +## Historical selected-family replay: #6030 + +The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), and [explicit source closure](../certificates/frontier6030-source.json). From d2e54af81f9dda6487636b79d4964a2385d89b2b Mon Sep 17 00:00:00 2001 From: Clear1nsight <22630354+Clear1nsight@users.noreply.github.com> Date: Wed, 11 Nov 2026 21:53:51 +1100 Subject: [PATCH 2/3] Replay the historical selected check at its inspected commit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The PR #6292 rejection census and package plan are statements about 2485805. Load its exact sources and planner in a private sparse checkout, keeping all source hashes, 19 expected rejections, nine package selections and the empty-plan control. Subsequent edits to the live Makefile and CI guide no longer invalidate this historical check. The original audit is by unpaidmoon, building on Dennis’s historical replay gate. The pinned repository view follows the precedent of Matarener’s PR #5434. Repair prepared with substantial OpenAI Codex assistance. --- .../historical-selected-replay-gap/README.md | 6 +- .../SOURCES.json | 60 +++++++++--------- .../VERIFY.json | 31 +-------- .../historical-selected-replay-gap/verify.py | 63 ++++++++++++++----- 4 files changed, 82 insertions(+), 78 deletions(-) diff --git a/research/historical-selected-replay-gap/README.md b/research/historical-selected-replay-gap/README.md index 55d8cc3b49..36d9a873ca 100644 --- a/research/historical-selected-replay-gap/README.md +++ b/research/historical-selected-replay-gap/README.md @@ -69,7 +69,11 @@ python3 -B scripts/research_package.py --package research/historical-selected-re The direct command prints `PASS_HISTORICAL_SELECTED_REPLAY_GAP`. A registered replay prints `PASS_REGISTERED_RESEARCH_PACKAGE`. Both require Git history -containing the two inspected commits. +containing the two inspected commits and the source and manifest objects at +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. The verifier uses a temporary +sparse checkout of that commit, checks the declared source digests there, and +uses its planner and manifest inventory. The recorded rejections and selection +therefore remain reproducible after later changes to the live Makefile or CI guide. ## Open next questions diff --git a/research/historical-selected-replay-gap/SOURCES.json b/research/historical-selected-replay-gap/SOURCES.json index c1010eec95..62bb8b3950 100644 --- a/research/historical-selected-replay-gap/SOURCES.json +++ b/research/historical-selected-replay-gap/SOURCES.json @@ -4,13 +4,13 @@ "files": [ { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "0d683a06b9e7ee162496108ce9a7c5d2ee94fccf", "sha256": "4f2d4f2dcd15139ec82658a975f85ed300897385f85799218539f4c8d60567da" }, { "path": "certificates/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "eccafa830c16170c36faf93045ddf1f638f7bcd4", "sha256": "4c0b9d37e1034b2076e30a70f8e514416298c462d9ee98bc87fe6556b14df786" }, @@ -22,7 +22,7 @@ }, { "path": "docs/ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "63ba3e9aa8bdc5e942b56e34244b92b16f854085", "sha256": "c7d3027e9ad8bcbff68f07aa9576b30fb2f3c76c44d876d40c7fdbf4a3e2228a" }, @@ -34,163 +34,163 @@ }, { "path": "research/clifford-state-performance/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "6f98a0061a5104dfab82c9e806f819b41811f684", "sha256": "396d0f08df24952248140d5c65c51b8c902ef1c580892ff7ea182890530f67ee" }, { "path": "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "5e0f92af463ec12c5e1dcc3effd44081a88af647", "sha256": "07a9daeaf2bda308a92e9a4684f13d5fc766c7772d74801fceb7f4599fdab226" }, { "path": "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "9e13266bf85e627f1b7dc225e9530ea69fd2c7f0", "sha256": "421e1211fb1897c45621dc6801c276e53f2e6f335583c9c9049e535f87c0a3b1" }, { "path": "research/community-batch932-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "cc4d03eb59b9ab3f952735f7e88ff18c2d15d7af", "sha256": "184629cac91a5cfaca50330a88596008b824221433867dcf8117539c913c284a" }, { "path": "research/community-batch970-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8b9f4111badf7de5d97684799560b55110e9da79", "sha256": "23188ed920e38a54006cb883e181585620821c63bf7e8b5e05d32719417cc37e" }, { "path": "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "a5300d4e7a5381a3f443fc54c768ca6f0f236d68", "sha256": "3c820fb30e1b4d9bcfc6a7ab524375e5b2abd66b940af2c509146104f0bcd79c" }, { "path": "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "d7ff6d777b01d69b6ce84caf25d3b7e4a4d2f211", "sha256": "6b185a9902652f893f3ebd8ada92d2f11b6de6533a9a4d11718a8a4496101128" }, { "path": "research/community-hyperplane599-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "546f37d326d10a99910ae8f908e71ef768524d98", "sha256": "65099d764bfcc39bda5e4d9966783611b094c3522dbdd1435cd498d657a8ef8e" }, { "path": "research/community-k492-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "e538481e4cb16ed936d3195f2dfb5b5a9ca0a76b", "sha256": "2c0f4fa5bc150d05658af2e7c54c4d2c337dd52b7efd3d69530ae73bcbdf452a" }, { "path": "research/community-reconciliation92-audit/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "2a2e93685173d5f13cbb5abe740f5d90352e0228", "sha256": "5f501f3c118131e7d069f30ad77186eb2ad6961f9680a0ef105f4514ed41808a" }, { "path": "research/partial-swap-digest/baseline.py", - "usage": "input", + "usage": "provenance", "git_blob": "a2f0190704db83bd8ef48e46e723c49b925804fe", "sha256": "81e9af92cdf38243a540cdcff2062778e449467848d444da37a9553c12ca4c34" }, { "path": "research/r420-two-sided-basis/SOURCES.json", - "usage": "input", + "usage": "provenance", "git_blob": "5d718e11e62f4bcadecf1e02d6b61f87dbe190b0", "sha256": "d9810b0d139c5a1211fd2c1f0d142187cc1fca30026e1e7bc4f9ecfacf1596d1" }, { "path": "research/skip-clones/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", "sha256": "0b68e63e35a97ce6b0cdb6e291b88ebaa8f2dd4afb70b2498f10ee89428258dc" }, { "path": "research/split-skip/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", "sha256": "7c2b4646a3ecfef6f881da5c43e4bd0fa9a4d1b00548b8ab458d897e16735134" }, { "path": "scripts/historical-ci-inputs/Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "aff68409021c9d401a6f8013b9dfd7dbcc30f2a8", "sha256": "ea8830dd79da493e2d75baf753d733ff7efbcf2b4794afe41fae0ac8f3055646" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "65db599ab0b1dea0312c4ca048e0bd0f44c3736f", "sha256": "96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "34820a8f24678f918f4d0e7a35380d8013fc3495", "sha256": "628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac" }, { "path": "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "c755b76e0d44ba4917aa94440ebe54daefce5b2a", "sha256": "d7fd929726b326aeeaf0a3996475adec88eee9aac09ae0bebeeaa0bc1fc8f199" }, { "path": "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "7f3c012504187917a728b9fe87043f0fc8cd006a", "sha256": "a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0" }, { "path": "scripts/historical-ci-inputs/partial-swap-context.json", - "usage": "input", + "usage": "provenance", "git_blob": "ad65114886bf34a4fd27e79f3be502389e689faa", "sha256": "833a9642f33aeab2ffea17ec9c6b82e0a953f90192b2c82e10bef21538dccba9" }, { "path": "scripts/historical-ci-inputs/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "52075f2463f60af5e16571347f24274fce73a1ea", "sha256": "f3c4be597b2f2136da4ae2cc80c7454f63c90aa01f84e5b8131cee4dd55de815" }, { "path": "scripts/partial_swap/shared.py", - "usage": "input", + "usage": "provenance", "git_blob": "44a0e454c70f9c4b98e258b8443612e6a119904b", "sha256": "5a0646a50b9f3e8ea55168620a78e8853b0ab810517cefc8cfb8696aedee278a" }, { "path": "scripts/replay_historical_check.py", - "usage": "input", + "usage": "provenance", "git_blob": "1e92fff2782970ef71378f594f2350d245a4db26", "sha256": "5467619c78183d3adc82b0cb55af28e5c1a01fca2b0588677816244b53e2bafd" }, { "path": "scripts/research_package.py", - "usage": "input", + "usage": "provenance", "git_blob": "091b4c8f58bac9a9580d76025b887dc5c873d05f", "sha256": "e1256016e7f51827d04fa2179255989f639ae1d97afaa9c16265f85a0c6abd70" }, { "path": "scripts/run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "a96ab35b315ce492e7fbbfd6c5ae211aa066b541", "sha256": "49eb56dd0fc0d8d8ffdb209970a7adf2176223580646f575d5c22e59543b381c" }, { "path": "scripts/verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "6882a4700e410dec569b51ae2eaf1a19cc019195", "sha256": "d6b305eac5b9bdb8172c469ad30a1655a60fa0aceac8b1bf610e1b73f51babd8" }, { "path": "tests/test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "343b24abf6719b81805eba5a84c74e57634c8288", "sha256": "3a5470d0b139828b90e19bf9583ddeafcd69f8e34f2824664eb3a2958a52e34d" } diff --git a/research/historical-selected-replay-gap/VERIFY.json b/research/historical-selected-replay-gap/VERIFY.json index 98553e72ed..ab7efa3471 100644 --- a/research/historical-selected-replay-gap/VERIFY.json +++ b/research/historical-selected-replay-gap/VERIFY.json @@ -4,36 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "Makefile", - "certificates/partial-swap-network.json", - "docs/ci-verification.md", - "research/clifford-state-performance/SOURCE.json", - "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "research/community-batch932-audit/CONTENT-COVERAGE.json", - "research/community-batch970-audit/CONTENT-COVERAGE.json", - "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "research/community-hyperplane599-audit/SOURCE.json", - "research/community-k492-audit/SOURCE.json", - "research/community-reconciliation92-audit/MANIFEST.json", - "research/partial-swap-digest/baseline.py", - "research/r420-two-sided-basis/SOURCES.json", - "research/skip-clones/SOURCE.json", - "research/split-skip/SOURCE.json", - "scripts/historical-ci-inputs/Makefile", - "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "scripts/historical-ci-inputs/partial-swap-context.json", - "scripts/historical-ci-inputs/partial-swap-network.json", - "scripts/partial_swap/shared.py", - "scripts/replay_historical_check.py", - "scripts/research_package.py", - "scripts/run_isolated_tests.py", - "scripts/verify_selected_result.py", - "tests/test_isolated_test_runner.py" + "scripts/research_package.py" ], "commands": [ { diff --git a/research/historical-selected-replay-gap/verify.py b/research/historical-selected-replay-gap/verify.py index 83b995941a..9d266c5a4e 100644 --- a/research/historical-selected-replay-gap/verify.py +++ b/research/historical-selected-replay-gap/verify.py @@ -6,8 +6,10 @@ """ import hashlib import importlib.util +import json import subprocess import sys +import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[2] @@ -61,31 +63,47 @@ def require(ok, message): raise SystemExit(message) -def load_checker(): - path = ROOT / "scripts/replay_historical_check.py" - spec = importlib.util.spec_from_file_location("historical_selected_replay_gap_checker", path) +def load_module(path): + spec = importlib.util.spec_from_file_location(path.stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module +def checkout_snapshot(snapshot, sources, runner, env): + paths = [runner.canonical_relative_path(row["path"]) for row in sources["files"]] + git = ["git", "-c", "maintenance.auto=false", "-c", "gc.auto=0", + "-c", "core.autocrlf=false"] + subprocess.run([*git, "clone", "--quiet", "--shared", "--no-tags", "--no-checkout", + "--", str(ROOT), str(snapshot)], cwd=ROOT, env=env, check=True) + subprocess.run([*git, "update-ref", "--no-deref", "HEAD", INSPECTED], + cwd=snapshot, env=env, check=True) + # The pinned planner reads omitted manifests from the sparse HEAD/index. + patterns = "".join(f"/{path.as_posix()}\n" for path in paths) + subprocess.run([*git, "sparse-checkout", "set", "--no-cone", "--stdin"], + cwd=snapshot, env=env, input=patterns.encode("utf-8"), check=True) + subprocess.run([*git, "read-tree", "-mu", "HEAD"], cwd=snapshot, env=env, check=True) + for path, row in zip(paths, sources["files"], strict=True): + require(hashlib.sha256((snapshot / path).read_bytes()).hexdigest() == row["sha256"], + "historical checkout source digest changed: " + path.as_posix()) + + def entries(checker): for name, config in checker.CONFIG.items(): for entry in [config, *config.get("additional_inputs", [])]: yield name, entry -def reject(checker, entry): +def reject(root, checker, entry): try: - checker.authenticated_input(ROOT, entry) + checker.authenticated_input(root, entry) except ValueError as exc: return str(exc) raise SystemExit("historical input was admitted: " + entry["path"]) -def main(): - require(not sys.flags.optimize, "assertions must stay enabled") - checker = load_checker() +def check_snapshot(root, env): + checker = load_module(root / "scripts/replay_historical_check.py") selected = [entry for name, entry in entries(checker) if name == "tooling-ledger" and entry["path"] == SELECTED_PATH] require(len(selected) == 1, "selected-result checker overlay is not unique") @@ -94,7 +112,7 @@ def main(): require(entry["accepted_live_sha256"] == [SELECTED_ACCEPTED], "accepted selected-checker successors changed") frozen = (checker.INPUTS / entry["input"]).read_bytes() - live = (ROOT / SELECTED_PATH).read_bytes() + live = (root / SELECTED_PATH).read_bytes() require(hashlib.sha256(frozen).hexdigest() == SELECTED_PIN, "frozen selected checker bytes changed") require(hashlib.sha256(live).hexdigest() == SELECTED_LIVE, "live selected checker digest changed") require(SELECTED_LIVE not in (SELECTED_PIN, SELECTED_ACCEPTED), "live checker was already admitted") @@ -102,7 +120,7 @@ def main(): # live successor, not a broken comparison. require(SELECTED_PIN in (SELECTED_PIN, *entry["accepted_live_sha256"]), "pin membership control failed") - require(reject(checker, entry) == REJECTIONS[SELECTED_PATH][1], + require(reject(root, checker, entry) == REJECTIONS[SELECTED_PATH][1], "selected checker rejection text changed") counts = {path: 0 for path in REJECTIONS} @@ -110,7 +128,7 @@ def main(): for _name, item in entries(checker): if item["path"] not in REJECTIONS: continue - message = reject(checker, item) + message = reject(root, checker, item) counts[item["path"]] += 1 messages.setdefault(item["path"], message) for path, (count, message) in REJECTIONS.items(): @@ -118,20 +136,31 @@ def main(): require(messages[path] == message, "rejection text changed for " + path) require(sum(counts.values()) == 19, "rejection total changed") ci = [item for _name, item in entries(checker) if item["path"] == CI_PATH] - require(len(ci) == 1 and hashlib.sha256((ROOT / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, + require(len(ci) == 1 and hashlib.sha256((root / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, "selected CI note digest changed") diff = subprocess.check_output( - ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=ROOT, text=True) + ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=root, env=env, text=True) changed = sorted(name for name in diff.splitlines() if name) require(changed == CHANGED, "inspected commit diff changed") - sys.path.insert(0, str(ROOT / "scripts")) - from research_package import plan_details - details = plan_details(ROOT, set(changed)) + planner = load_module(root / "scripts/research_package.py") + details = planner.plan_details(root, set(changed)) require([row["package"] for row in details] == PLAN_PACKAGES, "helper plan selection changed") matched = {name for row in details for names in row["causes"].values() for name in names} require(sorted(set(changed) - matched) == UNMATCHED, "unmatched plan paths changed") - require(plan_details(ROOT, set()) == [], "empty change set selected a package") + require(planner.plan_details(root, set()) == [], "empty change set selected a package") + + +def main(): + require(not sys.flags.optimize, "assertions must stay enabled") + sources = json.loads(Path(__file__).with_name("SOURCES.json").read_bytes()) + require(sources["base_commit"] == INSPECTED, "historical checkout base changed") + runner = load_module(ROOT / "scripts/research_package.py") + env = runner.git_source_env() + with tempfile.TemporaryDirectory(prefix="historical-selected-replay-") as temporary: + snapshot = Path(temporary) / "snapshot" + checkout_snapshot(snapshot, sources, runner, env) + check_snapshot(snapshot, env) print("PASS_HISTORICAL_SELECTED_REPLAY_GAP") print("selected_checker_live=" + SELECTED_LIVE) print("rejections=19 distinct_paths=7 plan_packages=9") From b4902a36a1506ab87cbdee03c51345b179fb00a6 Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Wed, 11 Nov 2026 17:18:02 -0800 Subject: [PATCH 3/3] Exclude signed Type B odd-even idle fusions --- .../LOCAL-PINS.json | 15 + .../p104-type-b-odd-even-idle-bound/NOTICE | 6 + .../p104-type-b-odd-even-idle-bound/PROOF.md | 15 + .../PROVENANCE.json | 37 ++ .../p104-type-b-odd-even-idle-bound/README.md | 24 ++ .../SOURCES.json | 18 + .../p104-type-b-odd-even-idle-bound/TASK.json | 84 ++++ .../VERIFICATION.md | 10 + .../VERIFY.json | 19 + .../independent/direct_impulse.py | 170 +++++++++ .../inputs/screen.py | 360 ++++++++++++++++++ .../lead/projector_gate.py | 74 ++++ .../price/inputs/7113-CALLER.json.gz | Bin 0 -> 11215 bytes .../price/inputs/7334-ADMITTED.json | 58 +++ .../price/inputs/7334-READBACK.json | 188 +++++++++ .../price/inputs/R53-PRICE.json.gz | Bin 0 -> 15355 bytes .../price/inputs/R59-PRICE.json.gz | Bin 0 -> 15162 bytes .../price/inputs/derivative_check.py | 67 ++++ .../price/inputs/pricing.py | 82 ++++ .../price/quote.py | 167 ++++++++ .../receipts/MASK-ADMISSION.json | 9 + .../receipts/SHA256.json | 5 + .../p104-type-b-odd-even-idle-bound/replay.py | 108 ++++++ 23 files changed, 1516 insertions(+) create mode 100644 research/p104-type-b-odd-even-idle-bound/LOCAL-PINS.json create mode 100644 research/p104-type-b-odd-even-idle-bound/NOTICE create mode 100644 research/p104-type-b-odd-even-idle-bound/PROOF.md create mode 100644 research/p104-type-b-odd-even-idle-bound/PROVENANCE.json create mode 100644 research/p104-type-b-odd-even-idle-bound/README.md create mode 100644 research/p104-type-b-odd-even-idle-bound/SOURCES.json create mode 100644 research/p104-type-b-odd-even-idle-bound/TASK.json create mode 100644 research/p104-type-b-odd-even-idle-bound/VERIFICATION.md create mode 100644 research/p104-type-b-odd-even-idle-bound/VERIFY.json create mode 100644 research/p104-type-b-odd-even-idle-bound/independent/direct_impulse.py create mode 100644 research/p104-type-b-odd-even-idle-bound/inputs/screen.py create mode 100644 research/p104-type-b-odd-even-idle-bound/lead/projector_gate.py create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/7113-CALLER.json.gz create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/7334-ADMITTED.json create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/7334-READBACK.json create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/R53-PRICE.json.gz create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/R59-PRICE.json.gz create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/derivative_check.py create mode 100644 research/p104-type-b-odd-even-idle-bound/price/inputs/pricing.py create mode 100644 research/p104-type-b-odd-even-idle-bound/price/quote.py create mode 100644 research/p104-type-b-odd-even-idle-bound/receipts/MASK-ADMISSION.json create mode 100644 research/p104-type-b-odd-even-idle-bound/receipts/SHA256.json create mode 100644 research/p104-type-b-odd-even-idle-bound/replay.py diff --git a/research/p104-type-b-odd-even-idle-bound/LOCAL-PINS.json b/research/p104-type-b-odd-even-idle-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..d08ecb9881 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/LOCAL-PINS.json @@ -0,0 +1,15 @@ +{ + "independent/direct_impulse.py": "d04426aed9528aedc6400d384d7fd13c6531e5e3e6592a7eea4faee46c61e004", + "inputs/screen.py": "cdf54b266ac31fd0efe544badbb9840598d4c63c4d3cd363f60ae9a74cc4b256", + "lead/projector_gate.py": "dd5e2a187968ead297b5cf5ce510bed0d1a88804688addd6a8abd18c02a91bac", + "price/inputs/7113-CALLER.json.gz": "7e8038559cd158f6e32ef6d1a3bf15ab6a8ecc2239af32ab1699511ac28e26d9", + "price/inputs/7334-ADMITTED.json": "c95300e9bca27e44a25c82d794f88cbf70757c142806b0e4c590ea29feb81a13", + "price/inputs/7334-READBACK.json": "337668788fb39ec9575887f9c5faf438a880471f78d936357dabf7deeac5de82", + "price/inputs/R53-PRICE.json.gz": "c6111b80f3e964733c38ea1ca46c762b90e38b30bab771cbc9df8c97dd6c888a", + "price/inputs/R59-PRICE.json.gz": "c7e55bd6bf1e5c48661cb285c4b0678e4cd8cc6cf3823d55dc7bf378a6e0f1a2", + "price/inputs/derivative_check.py": "348c8b2de72f1f112cb1337eca9d29ca96c85a7ad903beecafb1a2a1221f408e", + "price/inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "price/quote.py": "6757d1f60533e42c5f42c085dd9300338825b0b4642f4e977fd148ac9a143de0", + "receipts/MASK-ADMISSION.json": "a6a59156f0d9e91197a071a06401c6b159d5252e00d6bc3d289e3ebae70b2fa8", + "receipts/SHA256.json": "877af2f9d65e0457e74f843a6ede78571ffdf9d57e7565d383c3c4d6be91d54c" +} diff --git a/research/p104-type-b-odd-even-idle-bound/NOTICE b/research/p104-type-b-odd-even-idle-bound/NOTICE new file mode 100644 index 0000000000..4ba7a5f0e5 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/NOTICE @@ -0,0 +1,6 @@ +Apache-2.0. + +#7315 supplies the even census and derivative method, #7323 the odd census, +#7334 the independently reproduced comparator, #7113 the signed caller, and +#7298 the directed tariff. #7296 studies the identical 1339/2324 pair under +a canonical erased-child volume model. OpenAI Codex and subagents materially assisted. diff --git a/research/p104-type-b-odd-even-idle-bound/PROOF.md b/research/p104-type-b-odd-even-idle-bound/PROOF.md new file mode 100644 index 0000000000..243e508bd8 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/PROOF.md @@ -0,0 +1,15 @@ +# Exact derivative obstruction at the retained odd clock + +The original 17-stage Type B port has 36 roles, four signed singleton odd idles, and 60 even idles. The eligible masks are nonempty and disjoint. There are 180 keys, including 128 singleton even receivers, eight each at sizes 2–7, and four at size 8. + +Set q=+1 and every independent body variable to one. Both original idle factors and the candidate union are identity at that specialization, so all unchanged local factors and their derivatives agree. Let F_i be the original prefix immediately before clock i. A body variable in the even mask contributes the transported rank-one projector F_e⁻¹ E_e F_e in the original left-normalized derivative. In the proposed word its contribution is F_o⁻¹ E_o F_o. Disjointness makes the retained odd-mask derivative unchanged. Endpoint equality for arbitrary inputs and all body values therefore requires equality of those transported projectors. + +Let B be the literal chronological action from just after the earlier idle to just before the later one. Equality implies B E_early=E_late B. Applying this to the earlier active basis vector implies its output column under B has no coordinate outside the later active role. The independent replay finds a nonzero exact rational off-axis coordinate on every key. Its reduction modulo 65521 is exactly the nonzero coordinate reported by the primary replay. The first specialization is decisive. + +The whole-stock price uses weights 8(H9+H_(8m)−H_(8m+9)), with H_r=r^(1−κ). Count each odd and even literal clock at most once. A four-odd-bit dynamic program over the 60 even clocks maximizes the sum of directed upper weights. Its maximizing witness uses four receiver sizes (7,7,8,8), with exact ceiling + +```text +480636778147886845668502850287975147915282102393/156250000000000000000000000000000000000000000000 +``` + +The matching grants compatibility and all ancillary work free. It certifies no legal compound edit or physical provider. #7296 separately excludes the identical pair (1339,2324) under a canonical parity-scalar erased-child model and its stated field-volume cost. The logical derivative proof applies to the entire stated single-role, original-odd-clock stock. diff --git a/research/p104-type-b-odd-even-idle-bound/PROVENANCE.json b/research/p104-type-b-odd-even-idle-bound/PROVENANCE.json new file mode 100644 index 0000000000..da0604c50e --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/PROVENANCE.json @@ -0,0 +1,37 @@ +{ + "derived_receipts": { + "price/inputs/7334-ADMITTED.json": { + "role": "independent exact #7334 admission", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7338" + }, + "price/inputs/R53-PRICE.json.gz": { + "role": "all 60 even idle masks", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7315", + "uncompressed_sha256": "86f779c3eeb43563793e6ccb2227257ef732b2ca12fbbde2f9099988f903a484" + }, + "price/inputs/R59-PRICE.json.gz": { + "role": "four odd and 26 broad even idle masks", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7323", + "uncompressed_sha256": "b73057381860987c6de1666205e91a0e3d116a8299d8aa425682f5960609c21f" + } + }, + "files": { + "price/inputs/7113-CALLER.json.gz": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "9451ceaf6e8e037894680b549f3ef41c21b260d7", + "path": "research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json", + "sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json", + "uncompress": true + }, + "price/inputs/pricing.py": { + "commit": "c522451caf287bb3c16eaece72be4c263315dca4", + "git_blob": "40ec194017bda1d524bba4f07b188c53281419d0", + "path": "research/adjacent-owned-add-exchange-bound/pricing.py", + "sha256": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/c522451caf287bb3c16eaece72be4c263315dca4/research/adjacent-owned-add-exchange-bound/pricing.py", + "uncompress": false + } + }, + "schema_version": 1 +} diff --git a/research/p104-type-b-odd-even-idle-bound/README.md b/research/p104-type-b-odd-even-idle-bound/README.md new file mode 100644 index 0000000000..24f620d951 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/README.md @@ -0,0 +1,24 @@ +# Same-clock Type B odd/even idle fusion bound + +**NO VERIFIED GAIN. Exact conditional κ change 0%.** On independently reproduced [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) at `aaeec8c0acf01e99a5f331ef363a698d9c084ace`, test the exact signed [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) Type B caller at `07a76c5e2738882c0cb322278e56f6cae3c9885d`. Replace one signed singleton odd idle and one disjoint-mask even idle by one job at the original odd clock and role. Keep the original q inverse factor, union the body masks, and preserve every other literal operator. + +Two independent methods exhaust all 180 keys. At q=+1 and unit body, a normalized derivative for any removed even-mask variable requires equality of the odd and even transported rank-one projectors. All 180 have a nonzero off-axis exact column. The rational coefficient reduces to the primary modular witness for every key. Zero cases remain unresolved. No q=−1, nonunit, formal or physical follow-up is needed. [Proof](PROOF.md). + +At equal field volume the complete price for even mask size m replaces paid ranks 9 and 8m by 8m+9 across eight Type B ports. The one-edit gross upper is 0.7850445440362529 raw at the incumbent crossing. The exact weighted matching grants at most four compatible disjoint-call edits and a gross upper of 3.076075380146476 raw. This grants all ancillary costs and all compatibility beyond literal disjoint calls and masks. The fixed moonshot still has more than 136.39071 raw units of deficit. A single added paid rank-one position kills every individual edit through the retained BIT cap. Exact endpoint support reduces this scoped one-edit credit to zero. + +## Replay + +Use CPython 3.12 with assertions and the standard library. From a clean checkout: + +```sh +python3.12 -I -B research/p104-type-b-odd-even-idle-bound/replay.py +python3.12 -B scripts/research_package.py --package research/p104-type-b-odd-even-idle-bound +``` + +Use `--out` with a fresh directory for the three deterministic receipts. The replay authenticates the compressed caller and its public Git object, regenerates the complete price and both proofs, compares each witness, and rejects changed caller bytes. [Verification details](VERIFICATION.md). + +## Open next questions + +A changed multi-role provider would need to preserve both distinct body derivative projectors. Pin its phase/body action and fully charge its volume, setup, owner restoration, routing, precision and tape before constructing a candidate. Other clocks, changed roles and simultaneous endpoint cancellation are outside this one-edit test. + +Credit #7315 for the even census and derivative method; #7323 for the odd census and separate phase-transfer exclusion; #7334 for the exact comparison; #7113 for the signed caller; and #7298 for directed pricing. #7296 studies the identical pair (1339,2324) under its different canonical parity-scalar erased-child volume model. OpenAI Codex and subagents materially assisted. diff --git a/research/p104-type-b-odd-even-idle-bound/SOURCES.json b/research/p104-type-b-odd-even-idle-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "path": "certificates/selected-result.json", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "usage": "provenance" + }, + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/p104-type-b-odd-even-idle-bound/TASK.json b/research/p104-type-b-odd-even-idle-bound/TASK.json new file mode 100644 index 0000000000..e05d701a06 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/TASK.json @@ -0,0 +1,84 @@ +{ + "actual_scope": "One disjoint-mask signed singleton odd and one even IDLE_ONE in exact #7113, fused at the original odd clock and role. Retain the original signed factor and all other operators.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent audit and packaging.", + "author": "Signed Type B odd/even idle research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "At fixed equal volume a union job would remove one paid child across eight ports; exact normalized derivatives exclude all 180 pairs.", + "budget_minutes": 5, + "evidence": "All 180 keys fail the exact q=+1 unit-body derivative gate. Independent rational column witnesses reduce to all modular witnesses.", + "open_questions": [ + { + "blocked_by": "The original single-slot signed union fails exact logical support at every eligible pair.", + "first_step": "Specify and price an admitted provider with distinct signed responses and fully charge routing and volume.", + "question": "Can a changed multi-role idle interface preserve both derivative projectors at positive complete price?", + "why_it_matters": "A one-role body union cannot realize the two distinct chronological projectors." + } + ], + "original_card": { + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "existing_checks": [ + { + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "status": "author-checked" + }, + { + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "status": "reviewed" + } + ], + "first_experiment": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "id": "joint-query-controller", + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "overlap_terms": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "Apply the even/even projector method to a signed odd/even union with the original odd phase retained.", + "scope_status": "changed", + "stop_rule": "At most 180 keys or 20 seconds at q=+1 and unit body. Further phases and physical tests only after a surviving necessary condition.", + "task_id": "joint-query-controller" +} diff --git a/research/p104-type-b-odd-even-idle-bound/VERIFICATION.md b/research/p104-type-b-odd-even-idle-bound/VERIFICATION.md new file mode 100644 index 0000000000..e0e97d5f07 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/VERIFICATION.md @@ -0,0 +1,10 @@ +# Exact replay and source pins + +LOCAL-PINS.json pins every replay dependency by relative path. PROVENANCE.json identifies the exact public caller and tariff and the two predecessor censuses. The first ordered-mask comparison rejected admission before support: 14 descending literal lists differ in order from their canonical sorted versions. The corrected check requires exact role and unique stage-set agreement. MASK-ADMISSION.json records the original failure hash, and the replay checks all 14 order differences directly. + +- PRICE.json rebuilds the complete 17-copy #7334 price, the 180 keys, all mask-size prices, the exact whole-stock matching and one-extra-rank-one derivative. +- LEAD.json regenerates all primary finite-field projector witnesses. +- INDEPENDENT.json checks the original q=+1 endpoint on all 36 basis columns, then independently replays each direct interval over the rationals. The replay reduces every exact off-axis witness to the primary residue. +- Controls cover swapped projectors and exact nonzero column and row shear, plus changed caller bytes. + +All 180 keys exhausted the first necessary gate. No later phase, formal or physical gate was needed. The selected result remains separate. diff --git a/research/p104-type-b-odd-even-idle-bound/VERIFY.json b/research/p104-type-b-odd-even-idle-bound/VERIFY.json new file mode 100644 index 0000000000..79a4eed7fb --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Rebuild exact whole-stock price and both 180-pair projector exclusions; reduce every rational witness modulo the primary prime and reject a changed caller.", + "timeout_seconds": 90 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-type-b-odd-even-idle-bound/independent/direct_impulse.py b/research/p104-type-b-odd-even-idle-bound/independent/direct_impulse.py new file mode 100644 index 0000000000..14b5e8bb18 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/independent/direct_impulse.py @@ -0,0 +1,170 @@ +"""Independent exact direct interval projector comparison for R85.""" +from argparse import ArgumentParser +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from time import monotonic + +PRICE = "33aad506112912ddf0721a2b007d9194eaa02e5792aceda2f9774f8838511262" +ADMISSION = "c95300e9bca27e44a25c82d794f88cbf70757c142806b0e4c590ea29feb81a13" +CALLER = "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CAP, SECONDS = 180, 20 + + +class Capped(Exception): + pass + + +def need(condition, text): + if not condition: + raise ValueError(text) + + +def read(path, expected): + raw = path.read_bytes() + need(sha256(raw).hexdigest() == expected, "changed input " + path.name) + return loads(raw) + + +def gates(event, offset, q): + family, op, *a = event + if family == "J": + u, v, l, r = a[1] + u, v = u - offset, v - offset + return [("add", u, v, q * Q(l)), ("add", v, u, Q(r) / q)] + if family != "B": + need(family == "A", "unknown event family") + return [] + dest, *tail = a + dest -= offset + if op == "ADD": + return [("add", dest, tail[0] - offset, Q(tail[1]))] + if op == "QUERY": + return [("add", dest, tail[0] - offset, q ** tail[1])] + if op == "SWAP": + return [("swap", dest, tail[0] - offset, Q(1))] + if op == "SCALE": + return [("scale", dest, dest, Q(tail[0]))] + if op == "IDLE_ODD": + return [("scale", dest, dest, q ** tail[1])] + need(op in ("IDLE_ONE", "LAMBDA"), "unknown Type B op") + return [] + + +def basis(n, i): + return [Q(k == i) for k in range(n)] + + +def apply(op, vector, transpose=False): + kind, d, s, c = op + if kind == "add": + if transpose: + d, s = s, d + if vector[s]: + vector[d] += c * vector[s] + elif kind == "scale": + vector[d] *= c + else: + need(kind == "swap", "bad gate") + vector[d], vector[s] = vector[s], vector[d] + + +def between(items, early_role, late_role, n): + column = basis(n, early_role) + for op in items: + apply(op, column) + for i, x in enumerate(column): + if i != late_role and x: + return "column", i, x + row = basis(n, late_role) + for op in reversed(items): + apply(op, row, True) + for i, x in enumerate(row): + if i != early_role and x: + return "row", i, x + need(column[late_role] == row[early_role] and column[late_role], "singular interval action") + return None + + +def controls(): + need(between([("swap", 0, 1, Q(1))], 0, 1, 2) is None, "valid swapped projector rejected") + need(between([("add", 1, 0, Q(-2))], 0, 0, 2) == ("column", 1, Q(-2)), + "mixed impulse column not rejected") + need(between([("add", 0, 1, Q(-3, 2))], 0, 0, 2) == ("row", 1, Q(-3, 2)), + "mixed covector row not rejected") + return ["swapped projector", "negative column shear", "fractional row shear"] + + +def literal_stock(events, offset): + odd, even = {}, {} + for i, e in enumerate(events): + if e[:2] == ["B", "IDLE_ODD"]: + need(len(e[3]) == 1 and e[4:] == [-1], "unexpected signed odd idle") + odd[i] = [e[2] - offset, sorted(e[3])] + if e[:2] == ["B", "IDLE_ONE"]: + even[i] = [e[2] - offset, sorted(e[3])] + return odd, even + + +def main(args): + tests = controls() + price, admission = read(args.price, PRICE), read(args.admission, ADMISSION) + need(price["head"] == admission["head"] == HEAD and admission["exit"] == 0 and + price["caller_sha256"] == CALLER and price["limits"]["first_cases"] == CAP and + price["limits"]["first_seconds"] == SECONDS, "price mismatch") + started = monotonic() + caller = read(args.caller, CALLER) + data = caller["types"]["B"] + n, off = data["roles"], data["offset"] + need((caller["stages"], n, off, len(data["ports"])) == (17, 36, 36, 8), "wrong Type B contract") + old, new = literal_stock(caller["events"], off) + need({str(k): v for k, v in old.items()} == price["odd_jobs"] and + {str(k): v for k, v in new.items()} == price["even_jobs"], "exact literal census differs") + keys = [{"odd": o, "even": e, "size": len(b)} for o, (_, a) in sorted(old.items()) + for e, (_, b) in sorted(new.items()) if set(a).isdisjoint(b)] + need(keys == price["keys"] and len(keys) == CAP, "exact key stock differs") + q = Q(1) + flattened = [] + offsets = [0] + for event in caller["events"]: + flattened.extend(gates(event, off, q)) + offsets.append(len(flattened)) + for i in range(n): + vector = basis(n, i) + for op in flattened: + apply(op, vector) + need(vector == basis(n, i), "old exact unit endpoint differs") + roles = {t: v[0] for t, v in (old | new).items()} + outcomes = [] + for key in keys: + if monotonic() - started >= SECONDS - 2: + break + a, b = sorted((key["odd"], key["even"])) + # Original old idles are identity at q=+1, unit body, so both boundaries can be omitted. + interval = flattened[offsets[a + 1]:offsets[b]] + witness = between(interval, roles[a], roles[b], n) + result = {"key": [key["odd"], key["even"]], "mask_size": key["size"], + "chronological_roles": [roles[a] + off, roles[b] + off]} + if witness is None: + result |= {"status": "provisional_projectors_equal"} + else: + side, role, value = witness + result |= {"status": "excluded", "exact_off_axis": [side, role + off, str(value)]} + outcomes.append(result) + unvisited = keys[len(outcomes):] + return {"status": "CAPPED" if unvisited else "EXHAUSTED", "head": HEAD, "price_sha256": PRICE, + "caller_sha256": CALLER, "admission_sha256": ADMISSION, "case_cap": CAP, + "runner_cap_seconds": SECONDS, "q": 1, "body": "unit", "old_endpoint_columns": n, + "controls": tests, "tested": len(outcomes), "outcomes": outcomes, + "counts": dict(Counter(row["status"] for row in outcomes)), "unvisited": unvisited, + "survivors": [row["key"] for row in outcomes if row["status"] != "excluded"]} + + +if __name__ == "__main__": + p = ArgumentParser() + for name in ("price", "admission", "caller"): + p.add_argument("--" + name, type=Path, required=True) + print(dumps(main(p.parse_args()), sort_keys=True, indent=2)) diff --git a/research/p104-type-b-odd-even-idle-bound/inputs/screen.py b/research/p104-type-b-odd-even-idle-bound/inputs/screen.py new file mode 100644 index 0000000000..8ccb073f0b --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/inputs/screen.py @@ -0,0 +1,360 @@ +"""Priced Type B idle pairing and bounded signed projector transport.""" + +from argparse import ArgumentParser +from bisect import bisect_left, bisect_right +from collections import Counter, defaultdict +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +from heapq import heapify, heappop, heappush +from itertools import combinations +import json +from math import isqrt +from pathlib import Path +import runpy +from time import monotonic + +HEAD = "ed090b57ed88f8859e5ff4643645099e6ba856ea" +CALLER_HEAD = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +PINS = { + "round30/complex/source/inputs/WORD.json.gz": "2c523ce6fdd6092d758fedc3602a0bcedb692b9766f1e41f903351ba4dee1756", + "round30/complex/source/inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "round30/complex/source/inputs/EARLY-RESULT.json": "691025fe95c7938a6da211244d4d5b6187d88a9de1acff0862eeb7f0ce7deaa7", + "7298/verify.py": "4a4291c9019ef23c664ae9646b076dc57054b49f5c5ffd21908aa9f0edf19902", + "7298/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "7298/RESULT.json": "aaf594b981f37e7dbddb12fd052d9286cf5c8c95c8d5265ab6426408f6e58cc5", + "7113/research/signed-caller-8x9/replay/supplier7112/short-caller/check_odd_physical_binding.py": + "5c80c3b0415a7f91d216395248dd6f13297eed637732098e1ca8fb0548951b98", +} +MOD = 65521 +N = 36 +BODIES = (tuple(range(2,19)), (19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89)) +CAP = {"body1":22, "nonunit":22, "structural":42} + + +def unpack(raw): + return json.loads(gzip.decompress(raw) if raw[:2] == b"\x1f\x8b" else raw) + + +def save(out,name,payload): + raw = (json.dumps(payload,sort_keys=True,indent=2)+"\n").encode() + tmp = out/(name+".tmp") + tmp.write_bytes(raw) + tmp.replace(out/name) + return sha256(raw).hexdigest() + + +def authenticate(roots): + files = {} + for key, pin in PINS.items(): + label,path = key.split("/",1) + raw = (roots[label]/path).read_bytes() + if sha256(raw).hexdigest() != pin: + raise ValueError(f"Changed input {key}") + files[key] = raw + return files + + +def maximum_matching(jobs): + groups = defaultdict(list) + for clock,role,stage in jobs: + groups[stage].append(clock) + heap = [(-len(g),s) for s,g in groups.items()] + heapify(heap) + selected = [] + while len(heap) > 1: + na,a = heappop(heap) + nb,b = heappop(heap) + selected.append(sorted((groups[a].pop(),groups[b].pop()))) + if na < -1: + heappush(heap,(na+1,a)) + if nb < -1: + heappush(heap,(nb+1,b)) + counts = Counter(j[2] for j in jobs) + upper = min(len(jobs)//2,len(jobs)-max(counts.values(),default=0)) + assert len(selected) == upper and len({x for pair in selected for x in pair}) == 2*upper + return selected,counts + + +def price(roots): + files = authenticate(roots) + base = "round30/complex/source/inputs/" + word,caller,early = (unpack(files[base+name]) for name in ("WORD.json.gz","CALLER.json","EARLY-RESULT.json")) + old = runpy.run_path(str(roots["7298"]/"verify.py")) + audit = old["complex_scan"](word,caller,early) + assert json.loads(json.dumps(audit)) == unpack(files["7298/RESULT.json"])["complex"] + binding = next(raw for key,raw in files.items() if key.startswith("7113/")) + assert b"rank = 8*len(selected)" in binding + assert (caller["stages"],caller["types"]["B"]["offset"],caller["types"]["B"]["roles"]) == (17,36,36) + ports = len(caller["types"]["B"]["ports"]) + assert ports == 8 + jobs = [(i,e[2]-36,e[3][0]) for i,e in enumerate(caller["events"]) + if e[:2] == ["B","IDLE_ONE"] and len(e[3]) == 1] + assert len(jobs) == 34 and all(0 <= r < N and 1 <= stage <= 17 for _,r,stage in jobs) + cases = [(s[0],t[0]) for s,t in combinations(jobs,2) if s[2] != t[2]] + assert len(cases) == 544 + matching,counts = maximum_matching(jobs) + assert set(map(tuple,matching)) <= set(cases) + kappa = Q(audit["probe"]) + paid = Counter({int(k):v for k,v in early["invoice"]["P"].items()}) + targets = Counter({int(k):v for k,v in early["invoice"]["T"].items()}) + assert (sum(paid.values()),sum(targets.values()),audit["copies"]) == (110536,22461,17) + net = targets.copy() + net.subtract(paid) + delta = {8:2*ports,16:-ports} + changed = net.copy() + changed.update(delta) + cost = old["PRICING"]["cost"] + old_margin,new_margin,credit = cost(net,kappa),cost(changed,kappa),cost(delta,kappa) + assert old_margin[1] < 0 < new_margin[0] and credit[0] > 0 + h8 = old["PRICING"]["power_bounds"](8,kappa) + h16 = old["PRICING"]["power_bounds"](16,kappa) + report = { + "head":HEAD, "caller_head":CALLER_HEAD, "inputs":PINS, "crossing_upper":str(kappa), + "native_copies":audit["copies"], "type_b_ports":ports, "old_complete_paid":paid, + "old_complete_targets":targets, "old_complete_margin":list(map(str,old_margin)), + "one_pair_paid_old_minus_new":delta, "one_pair_complete_margin":list(map(str,new_margin)), + "one_pair_moment_credit":list(map(str,credit)), + "break_even_volume_factor":list(map(str,(2*h8[0]/h16[1],2*h8[1]/h16[0]))), + "whole_compatible_optimistic_upper":str(len(matching)*credit[1]), + "maximum_disjoint_pairs":len(matching), "illustrative_matching":matching, + "stage_counts":counts,"jobs":jobs,"pair_keys":cases, + "new_work_assumed_free_in_price":True, + "predeclared_followup":{"nonunit_body_vectors":BODIES,"nonunit_hard_seconds":25, + "structural_hard_seconds":45,"structural_max_cases":3}, + } + return report,caller + + +def field_scalar(raw): + q = Q(raw) + if q.denominator % MOD == 0: + raise ValueError("Nonunit modular denominator") + return q.numerator*pow(q.denominator,-1,MOD)%MOD + + +def compile_gates(caller,q,body): + gates = [] + for i,event in enumerate(caller["events"]): + kind,op,*args = event + if kind == "J": + s,t,a,b = args[1] + a,b = field_scalar(a),field_scalar(b) + m = body[op-1] + h = (m,m*a*q%MOD,m*b*q%MOD,m*(1+a*b)%MOD) + assert (h[0]*h[3]-h[1]*h[2])%MOD + gates.append((i,"J",s-36,t-36,h)) + elif kind == "B": + d = args[0]-36 + assert 0 <= d < N + if op == "ADD": + gates.append((i,op,d,args[1]-36,field_scalar(args[2]))) + elif op == "QUERY": + gates.append((i,"ADD",d,args[1]-36,pow(q,args[2]%4,MOD))) + elif op == "SWAP": + gates.append((i,op,d,args[1]-36,0)) + elif op == "SCALE": + value = field_scalar(args[1]) + assert value + gates.append((i,op,d,d,value)) + elif op in ("IDLE_ONE","IDLE_ODD"): + value = pow(q,args[2]%4,MOD) if op == "IDLE_ODD" else 1 + for stage in args[1]: + value = value*body[stage-1]%MOD + assert value + if value != 1: + gates.append((i,"SCALE",d,d,value)) + elif op != "LAMBDA": + raise ValueError(op) + return [g[0] for g in gates],gates + + +def transport(gates,initial,row,mod=None,dimension=N): + vec = [0]*dimension + vec[initial] = 1 + mixed = False + for _,op,d,s,c in reversed(gates) if row else gates: + if op == "ADD": + to,frm = (s,d) if row else (d,s) + vec[to] += c*vec[frm] + if mod: + vec[to] %= mod + elif op == "SCALE": + vec[d] *= c + if mod: + vec[d] %= mod + elif op == "SWAP": + vec[d],vec[s] = vec[s],vec[d] + elif op == "J": + a,b,x,y = c + if row: + b,x = x,b + u,v = vec[d],vec[s] + vec[d],vec[s] = (a*u+b*v)%mod,(x*u+y*v)%mod + else: + raise ValueError(op) + if mod is None and sum(bool(x) for x in vec) > 1: + mixed = True + assert any(vec) + return vec,mixed + + +def outside(vec,axis): + return next(([i,v] for i,v in enumerate(vec) if i != axis and v),None) + + +def controls(): + gates = [(0,"ADD",1,0,1),(1,"SCALE",0,0,2),(2,"ADD",1,0,-1)] + assert outside(transport(gates,0,False,MOD,2)[0],0) == [1,MOD-1] + gates[1] = (1,"SCALE",0,0,1) + assert outside(transport(gates,0,False,MOD,2)[0],0) is None + assert outside(transport(gates,0,True,MOD,2)[0],0) is None + assert transport(gates,0,False,None,2)[1] + read = [(0,"ADD",0,1,1)] + assert outside(transport(read,0,True,MOD,2)[0],0) == [1,1] + assert outside(transport(read,0,False,MOD,2)[0],0) is None + match,_ = maximum_matching([(i,0,s) for i,s in enumerate([1,1,1,1,2,3])]) + assert len(match) == 2 + caller = {"events":[["B","IDLE_ONE",36,[1]],["B","ADD",37,36,"1"], + ["B","ADD",37,36,"-1"],["B","IDLE_ONE",36,[2]]]} + assert structural(caller,0,3,0,0) == ("formal_projector_transport",True,None) + caller["events"][2] = ["B","ADD",37,36,"1"] + assert structural(caller,0,3,0,0) == ("unresolved_endpoint",True,3) + return ["body_one_false_positive","genuine_nondiagonal_transient","outside_read_only", + "distinct_mask_matching_does_not_double_spend"] + + +def modular_stage(caller,jobs,cases,bodies,deadline): + compiled = [(v,q,*compile_gates(caller,q,body)) + for v,body in enumerate(bodies) for q in (1,MOD-1)] + records = [] + for left,right in cases: + if monotonic() >= deadline: + break + source,target = jobs[left],jobs[right] + witness = None + for v,q,clocks,gates in compiled: + interval = gates[bisect_right(clocks,left):bisect_left(clocks,right)] + write,_ = transport(interval,source,False,MOD) + read,_ = transport(interval,target,True,MOD) + bad_col,bad_row = outside(write,target),outside(read,source) + if bad_col or bad_row: + witness = {"vector_index":v,"q":1 if q == 1 else -1, + "outside_write":bad_col,"outside_read":bad_row} + break + records.append({"key":[left,right],"witness":witness}) + return records + + +def structural(caller,left,right,source,target): + r = source + block = [] + mixed = False + + def flush(axis): + vec,m1 = transport(block,axis,False) + nz = [i for i,v in enumerate(vec) if v] + if len(nz) != 1: + return None,True + end = nz[0] + dual,m2 = transport(block,end,True) + return (None if outside(dual,axis) else end),m1 or m2 + + for clock,event in enumerate(caller["events"][left+1:right],left+1): + kind,op,*args = event + if kind == "B" and op in ("ADD","SCALE","SWAP"): + d = args[0]-36 + if op == "ADD": + block.append((clock,op,d,args[1]-36,Q(args[2]))) + elif op == "SCALE": + block.append((clock,op,d,d,Q(args[1]))) + else: + block.append((clock,op,d,args[1]-36,0)) + continue + if kind not in ("B","J"): + continue + r,inner = flush(r) + mixed |= inner + block.clear() + if r is None: + return "unresolved_constant_block",mixed,clock + if kind == "J" and r in {args[1][0]-36,args[1][1]-36}: + return "unresolved_active_j",True,clock + if kind == "B" and op == "QUERY" and r in {args[0]-36,args[1]-36}: + return "unresolved_query",True,clock + r,inner = flush(r) + mixed |= inner + if r != target: + return "unresolved_endpoint",mixed,right + return ("formal_projector_transport" if mixed else "diagonal_path_overlap_pending"),mixed,None + + +def previous(out,name,price_sha): + value = json.loads((out/name).read_text()) + assert value["price_sha256"] == price_sha + return value + + +def main(args,start): + roots = {"round30":args.round30,"7298":args.predecessor,"7113":args.caller_root} + pre,caller = price(roots) + out = args.out + if args.stage in ("price","body1"): + price_sha = save(out,"PRICE.json",pre) + else: + frozen = (out/"PRICE.json").read_bytes() + assert unpack(frozen) == json.loads(json.dumps(pre)) + price_sha = sha256(frozen).hexdigest() + if args.stage == "price": + return + jobs = {j[0]:j[1] for j in pre["jobs"]} + cases = pre["pair_keys"] + checks = controls() + assert all(MOD%d for d in range(2,isqrt(MOD)+1)) + prior_unvisited = [] + if args.stage != "body1": + first = previous(out,"BODY1.json",price_sha) + cases = first["survivors"] + prior_unvisited = first["unvisited"] + if args.stage == "structural": + second = previous(out,"NONUNIT.json",price_sha) + cases = second["survivors"] + prior_unvisited = second["unvisited"] + deadline = start+CAP[args.stage] + if args.stage in ("body1","nonunit"): + bodies = ((1,)*17,) if args.stage == "body1" else BODIES + rows = modular_stage(caller,jobs,cases,bodies,deadline) + survivors = [r["key"] for r in rows if r["witness"] is None] + save(out,("BODY1.json" if args.stage == "body1" else "NONUNIT.json"),{ + "stage":args.stage,"price_sha256":price_sha,"prime":MOD,"body_vectors":bodies, + "scope":len(cases),"visited":len(rows),"exclusions":len(rows)-len(survivors), + "survivors":survivors,"unvisited":[*prior_unvisited,*cases[len(rows):]], + "records":rows,"controls":checks, + }) + return + rows = [] + for a,b in cases[:3]: + if monotonic() >= deadline: + break + status,mixed,at = structural(caller,a,b,jobs[a],jobs[b]) + rows.append({"key":[a,b],"status":status,"nondiagonal_transient":mixed,"stop_clock":at}) + save(out,"STRUCTURAL.json",{ + "price_sha256":price_sha,"scope":len(cases),"visited":len(rows),"hard_seconds":45, + "unvisited":[*prior_unvisited,*cases[len(rows):]], + "support_survivors":[r["key"] for r in rows if r["status"] == "formal_projector_transport"], + "unresolved":[r["key"] for r in rows if r["status"] != "formal_projector_transport"], + "records":rows,"controls":checks, + }) + + +if __name__ == "__main__": + start = monotonic() + if not __debug__: + raise RuntimeError("Assertions required") + parser = ArgumentParser(description=__doc__) + for flag in ("round30","predecessor","caller-root","out"): + parser.add_argument("--"+flag,type=lambda x:Path(x).resolve(),required=True) + parser.add_argument("--stage",choices=("price","body1","nonunit","structural"),default="body1") + args = parser.parse_args() + args.out.mkdir(parents=True,exist_ok=True) + main(args,start) diff --git a/research/p104-type-b-odd-even-idle-bound/lead/projector_gate.py b/research/p104-type-b-odd-even-idle-bound/lead/projector_gate.py new file mode 100644 index 0000000000..afb62649d6 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/lead/projector_gate.py @@ -0,0 +1,74 @@ +"""Exact modular transported projectors for odd/even idle fusion.""" +from bisect import bisect_left,bisect_right +from collections import Counter +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path +import sys +from time import monotonic + +HEAD="aaeec8c0acf01e99a5f331ef363a698d9c084ace" +PRICE="33aad506112912ddf0721a2b007d9194eaa02e5792aceda2f9774f8838511262" +CALLER="255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" +ENGINE="cdf54b266ac31fd0efe544badbb9840598d4c63c4d3cd363f60ae9a74cc4b256" + + +def checked(path,digest): + raw=path.read_bytes() + if sha256(raw).hexdigest()!=digest: + raise ValueError(f"changed dependency {path.name}") + return raw + + +def main(): + root=Path(sys.argv[1]) + price=json.loads(checked(root/"price/PRICE.json",PRICE)) + caller=json.loads(checked(root/"price/inputs/7113-CALLER.json",CALLER)) + assert price["head"]==HEAD and price["caller_sha256"]==CALLER + code=root/"inputs/screen.py" + checked(code,ENGINE) + s=run_path(str(code)) + p=s["MOD"] + controls=s["controls"]() + odd={int(k):v for k,v in price["odd_jobs"].items()} + even={int(k):v for k,v in price["even_jobs"].items()} + for clock,(role,mask) in odd.items(): + assert caller["events"][clock]==["B","IDLE_ODD",role+36,mask,-1] + for clock,(role,mask) in even.items(): + kind,op,field,literal_mask=caller["events"][clock] + assert (kind,op,field)==("B","IDLE_ONE",role+36) + assert sorted(literal_mask)==mask and len(set(literal_mask))==len(mask) + keys=price["keys"] + assert len(keys)==180 and len(odd)==4 and len(even)==60 + assert {(r["odd"],r["even"]) for r in keys}=={ + (i,j) for i,a in odd.items() for j,b in even.items() if not set(a[1])&set(b[1])} + sites=odd|even + clocks,gates=s["compile_gates"](caller,1,[1]*17) + deadline=monotonic()+18 + rows=[] + survivors=[] + for key in keys: + if monotonic()>=deadline: + break + left,right=sorted((key["odd"],key["even"])) + source,target=sites[left][0],sites[right][0] + interval=gates[bisect_right(clocks,left):bisect_left(clocks,right)] + col,_=s["transport"](interval,source,False,p) + row,_=s["transport"](interval,target,True,p) + bad_col,bad_row=s["outside"](col,target),s["outside"](row,source) + decision="excluded" if bad_col or bad_row else "provisional" + record=dict(key=key,chronological=[left,right],outside_column=bad_col,outside_row=bad_row, + decision=decision,source_role=source,target_role=target) + rows.append(record) + if decision=="provisional": + survivors.append(key) + print(json.dumps(dict(head=HEAD,price_sha256=PRICE,caller_sha256=CALLER, + q=1,body="all one",modulus=p,controls=controls,case_cap=180,seconds_cap=18, + decisions=rows,counts=Counter(x["decision"] for x in rows),provisional=survivors, + unvisited=keys[len(rows):],status="EXHAUSTED" if len(rows)==len(keys) else "CAPPED"), + indent=2,sort_keys=True)) + + +if __name__=="__main__": + main() diff --git a/research/p104-type-b-odd-even-idle-bound/price/inputs/7113-CALLER.json.gz b/research/p104-type-b-odd-even-idle-bound/price/inputs/7113-CALLER.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..2479c3a61579df01c0958406746c550381a55dde GIT binary patch literal 11215 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 PMn*AXLoONv`|UQv! literal 0 HcmV?d00001 diff --git a/research/p104-type-b-odd-even-idle-bound/price/inputs/7334-ADMITTED.json b/research/p104-type-b-odd-even-idle-bound/price/inputs/7334-ADMITTED.json new file mode 100644 index 0000000000..464c89e45c --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/price/inputs/7334-ADMITTED.json @@ -0,0 +1,58 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "base": "e54523517d0f03e58352e647c403a5af3e525a57", + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "crossing": [ + "0.00364665195644044790699554028334161", + "0.00364665195644044790699554028334162" + ], + "end": "2026-11-11T23:04:43Z", + "exit": 0, + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "hosted_at_admission": "plan and historical success; candidate replay in progress", + "inputs": { + "EARLY-RESULT.json": "ad1ca9b2e2febbf80d9bf8b6ceef14ff90fcc29ef9358310e551628eb1706649", + "INPUTS.json": "abedac59097a1c35c27d91cbdb07207bc562a64743bc406d13c94a8bc970592d", + "NATIVE-RESULT.json": "c6d1b00a83185ab0062397b363258b1f3f6685d755e9c1d4f7d3e7e511240812", + "PROPOSED-CLAIM.json": "6e31241944c123d2bd4aa8bc94d833b44b3d889bd6d9aafc579108f416b45f03", + "RESULT.json": "7f2d587c59f063b01f1e8b320084a7f0943f2f05d65e3e0f5e80448c6c8e8194", + "SOURCES.json": "ac7b4473035af648d6073e78b6c39675e706e8194b346bb55ed62a0adc81d593", + "VERIFY.json": "ede7dd2dd3733b9a73f72af9dd7edfe819b49b859c5c76e227ec82cb9c220513", + "WORD.json.gz": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a" + }, + "kappa": "0.00364665195644", + "ours": "0", + "peer_gain": "0.000000430519994", + "prior_kappa": "0.003646221436446", + "receipt": { + "peer-prep/IDENTITIES.json": "f4d3f6ca2d87f8cd68c01ac9f77b69bd5a796f92bd567cea8afe3ac7c72e8e4b", + "peer-prep/STATIC.json": "500cc563b7dac8b1de1faf1dee9b820e73152dfddc15a650cd1191edd39e8c79", + "peer-price/RANK-STOCK.json": "4a7841699dd17688f6aada5c902a2a91e94558b2b1b4460c46b0e55aa95b3f9f", + "peer-price/READBACK.json": "337668788fb39ec9575887f9c5faf438a880471f78d936357dabf7deeac5de82", + "peer/COMMAND.txt": "714bfab024155d8216f3ef99f3ee7627ddc35ab341c486ac6bd53c476b757130", + "peer/COMMIT.stdout": "597470d8132a3812deb3624a859546c0c13d52b094fd6fc61e7416941130bd70", + "peer/END-UTC.txt": "9c46923c616c14da5b8ed503e1652021d7bd409a10ec91a78a03263013fba08a", + "peer/METADATA.stdout": "5873404cb4424dca918a00d503569f3c29a3190fd029a007e1afb2006399f647", + "peer/RUN.exit": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa", + "peer/RUN.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "peer/RUN.stdout": "d589626c7581fbb9928bc615364cfee49deb62dfc0a39a903417ca62be89cf8c", + "peer/START-UTC.txt": "5b78fd6d42a2b42206891318c08e6014de57d7ca46b0201cd11a166f452210f7" + }, + "source_history": "exact anchored base and recursive package provenance, sparse shallow stock wrapper not executed", + "stages": { + "caller": "PASS_HELPER_319_FUSED_CALLER 91166298911/25000000000000", + "early": "PASS_HELPER_319_EXACT_NATIVE_AND_SIGNED_PRICE 0.00364665195644", + "frontier": "PASS_HELPER_319_FUSED_FRONTIER_PROPOSAL 91166298911/25000000000000", + "native": "PASS_HELPER_319_FUSED_NATIVE 3646017316711/1000000000000000" + }, + "start": "2026-11-11T22:54:48Z", + "status": "independently_reproduced_comparable", + "tree": "fa98712a459b20c10240450097c87de433f8a750" +} diff --git a/research/p104-type-b-odd-even-idle-bound/price/inputs/7334-READBACK.json b/research/p104-type-b-odd-even-idle-bound/price/inputs/7334-READBACK.json new file mode 100644 index 0000000000..625b508eea --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/price/inputs/7334-READBACK.json @@ -0,0 +1,188 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "bit_admitted": "12039/3125000", + "bit_claim_headroom": "3000951089/25000000000000", + "bit_premise": "376669/100000000", + "caller_head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "claim": "91166298911/25000000000000", + "context_c": 2430, + "context_headroom": 1666, + "copies": 17, + "directed_bounds": { + "new_at_claim": [ + "347195197206460540909548691538238227127/2000000000000000000000000000000000000000000000000", + "1735975986032302704547743457691191192207/10000000000000000000000000000000000000000000000000" + ], + "new_at_old_crossing_upper": [ + "333717954993733063339209580360321337006028706669/2000000000000000000000000000000000000000000000000", + "1668589774968665316696047901801606685030143589709/10000000000000000000000000000000000000000000000000" + ], + "new_at_raw_lower": [ + "8890529086421014119/10000000000000000000000000000000000000000000000000", + "8890529086421080299/10000000000000000000000000000000000000000000000000" + ], + "new_at_raw_upper": [ + "-29866980917152322049/10000000000000000000000000000000000000000000000000", + "-29866980917152266101/10000000000000000000000000000000000000000000000000" + ], + "new_at_tested": [ + "1464673416007288863003441470091977383033/10000000000000000000000000000000000000000000000000", + "1464673416007288863003441470091977438357/10000000000000000000000000000000000000000000000000" + ], + "old_at_claim": [ + "-1668785950738799647054310634446839861363893886031/10000000000000000000000000000000000000000000000000", + "-66751438029551985882172425377873594454555753177/400000000000000000000000000000000000000000000000" + ], + "old_at_old_crossing_upper": [ + "-357270001119021587349/10000000000000000000000000000000000000000000000000", + "-357270001119021530951/10000000000000000000000000000000000000000000000000" + ] + }, + "empty_root_credits": 0, + "exact_gain": "215259997/500000000000000", + "exact_relative_percent": "21525999700/1823110718223", + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "incumbent": "1823110718223/500000000000000", + "main_boundaries": 104, + "native_grid": [ + 1125, + 25 + ], + "native_ingredient_claim": "3646017316711/1000000000000000", + "new_raw_interval": [ + "364665195644044790699554028334161/100000000000000000000000000000000000", + "182332597822022395349777014167081/50000000000000000000000000000000000" + ], + "old_raw_upper": "36462214364462343366888845568981/10000000000000000000000000000000000", + "ordinary": 782715464, + "ordinary_delta": 52088, + "ordinary_headroom": 217284536, + "outer_functional": 4, + "outer_strict": 54, + "outer_strict_slack": "299635334804355997/10000000000000000000000000000000000", + "owned_lifetimes": 73, + "owned_peak": 50, + "paid": { + "1": 68384, + "2": 14501, + "3": 14093, + "4": 3791, + "5": 5865, + "6": 238, + "7": 170, + "8": 741, + "9": 32, + "16": 416, + "24": 416, + "32": 416, + "40": 416, + "48": 416, + "56": 416, + "64": 208 + }, + "paid_delta": { + "1": -17, + "5": -17, + "6": 17 + }, + "paid_positions": 110519, + "parent": "9d0119eb12fbd9fa534b48cd37b68e7099757b91", + "path_pins": { + "dependencies/7298/pricing.py": { + "sha256": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182" + }, + "dependencies/7314/NATIVE-RESULT.json": { + "sha256": "336f463da5afe5b60bfd3b9f0ce8aeea5a5feb1f854613bf4218ba0b28b3371b" + }, + "dependencies/7314/PROPOSED-CLAIM.json": { + "sha256": "41a08c4b7d0b2de4af22bc778948a143027eb3065fff47b0400b6ded1cc52778" + }, + "dependencies/7314/RESULT.json": { + "sha256": "432191ca572c9221935787ebe392699e3a1ef4512b0bf4fbc704657321cc87ca" + }, + "dependencies/round65/price.json": { + "sha256": "25205ad2cf4230bd2b2b704eec9f96ec4a5486fd575b5599861b28ffdd15b00b" + }, + "receipts/EARLY-RESULT.json": { + "git_blob": "675d6cf2374f3384019dfd53b2bdffd845005f13", + "sha256": "ad1ca9b2e2febbf80d9bf8b6ceef14ff90fcc29ef9358310e551628eb1706649" + }, + "receipts/INPUTS.json": { + "git_blob": "95c53f4594287a72d9b586f10ee136d0a1686984", + "sha256": "abedac59097a1c35c27d91cbdb07207bc562a64743bc406d13c94a8bc970592d" + }, + "receipts/NATIVE-RESULT.json": { + "git_blob": "eb101307d4d0399efed96d88cf6d4c01ec9c7369", + "sha256": "c6d1b00a83185ab0062397b363258b1f3f6685d755e9c1d4f7d3e7e511240812" + }, + "receipts/PROOF.md": { + "git_blob": "7644e5571d583183ee93b686612b5ec4555f6911", + "sha256": "560de573bfd4563c16ca3c7308fa729b4188fabe802d8830f343c3873f75b59d" + }, + "receipts/PROPOSED-CLAIM.json": { + "git_blob": "6b491894580741e3e2c11a453722a0302db7b5d6", + "sha256": "6e31241944c123d2bd4aa8bc94d833b44b3d889bd6d9aafc579108f416b45f03" + }, + "receipts/README.md": { + "git_blob": "b3a055f4e0d334ce2e7df3310caaa0849eb3eba1", + "sha256": "b4db0eb83ab6a2f7151bed2da955a487f4816ec9d1976eccc21e54c2725490b0" + }, + "receipts/REFERENCE.json": { + "git_blob": "8859e243cc39546bcb1e257d95c19a658c455dc7", + "sha256": "3e66e054b803551f18b8670da0b2990a7d0eeb689dfc45b56dbcba295551da70" + }, + "receipts/REPLAY.txt": { + "git_blob": "0b8d8048c18740060f4b7f6d380a5f3a0f30ee53", + "sha256": "230984f4b8206ae4d0c0f18fbba86ff43a1a9623f8ed337cf1285360f9a67c0c" + }, + "receipts/RESULT.json": { + "git_blob": "3034a490f5b0656ae71495c99493c4ab1ac1f5c6", + "sha256": "7f2d587c59f063b01f1e8b320084a7f0943f2f05d65e3e0f5e80448c6c8e8194" + }, + "receipts/SOURCES.json": { + "git_blob": "6b97e903a6df8de437068a0e2907823885928053", + "sha256": "ac7b4473035af648d6073e78b6c39675e706e8194b346bb55ed62a0adc81d593" + }, + "receipts/VERIFY.json": { + "git_blob": "cc98ee2a5c5a79e670094a6f55c7cacda8fd330c", + "sha256": "ede7dd2dd3733b9a73f72af9dd7edfe819b49b859c5c76e227ec82cb9c220513" + }, + "receipts/construct.py": { + "git_blob": "89e923bd738dfc404ca76b7ae36f13844ac4bfbb", + "sha256": "ecb39578063d7f09153a85370a3b9bb7cbf8b36ff9891033a1cce7a2fe7f7fda" + } + }, + "physical_maps": 3037, + "productive_fields": 22461, + "rank_surplus": 1424, + "raw_strict_separation": "43051999421357030665572644351/100000000000000000000000000000000000", + "scope": "Exact receipt and directed-price readback. No native or caller execution in this audit.", + "source_archive_sha256": "0589953b3886d96eacf3bda3d38d8d574bb739fba1056af7f32f56047b6061e2", + "targets": { + "1": 306, + "2": 357, + "3": 799, + "4": 3825, + "5": 1360, + "6": 731, + "7": 323, + "8": 544, + "9": 10888, + "17": 416, + "25": 416, + "33": 416, + "41": 416, + "49": 416, + "57": 416, + "65": 416, + "73": 208, + "137": 208 + }, + "tested": "364665195644007/100000000000000000" +} diff --git a/research/p104-type-b-odd-even-idle-bound/price/inputs/R53-PRICE.json.gz b/research/p104-type-b-odd-even-idle-bound/price/inputs/R53-PRICE.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..1214c4d5fef08e0cd5c6dbb328512d458b1b510f GIT binary patch literal 15355 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 after[key]: + after[key] = candidate + dp = after + return dp + + +def main(): + raw = {name: file(name) for name in PINS} + r59, r53, admitted, r68 = (loads(raw[name], object_pairs_hook=unique) for name in + ("R59-PRICE.json", "R53-PRICE.json", "7334-ADMITTED.json", "7334-READBACK.json")) + check(admitted["head"] == r68["head"] == HEAD and admitted["exit"] == 0, "wrong comparator") + check(r59["caller_head"] == r53["caller_head"] == admitted["caller"] == r68["caller_head"] == CALLER, + "wrong caller") + check(admitted["caller_sha256"] == PINS["7113-CALLER.json"] and r53["type_b_ports"] == 8 and r68["copies"] == 17, + "wrong signed caller census") + odd = {int(c): row for c, row in r59["odd_jobs"].items()} + even = {c: [r, stages] for c, r, stages in r53["job_masks"]} + check(len(odd) == 4 and len(even) == 60 and not odd.keys() & even.keys(), "wrong idle stock") + check({c: [r, sorted(mask)] for c, (r, mask) in even.items() if len(mask) > 1} == + {int(c): [r, sorted(mask)] for c, (r, mask) in r59["even_jobs"].items()}, + "inconsistent larger even stock") + check(sorted(odd) == [1339, 1340, 2970, 2971] and all(len(v[1]) == 1 for v in odd.values()), + "wrong odd singleton stock") + keys = [{"odd": o, "even": e, "size": len(b)} for o, (_, a) in sorted(odd.items()) + for e, (_, b) in sorted(even.items()) if set(a).isdisjoint(b)] + counts = Counter(key["size"] for key in keys) + check(len(keys) == 180 and counts == {1: 128, 2: 8, 3: 8, 4: 8, 5: 8, 6: 8, 7: 8, 8: 4}, + "wrong disjoint key count") + check(any((p["odd"], p["even"]) == (1339, 2324) for p in keys), "missing overlap control") + + paid, targets = inv(r68["paid"]), inv(r68["targets"]) + net = targets.copy() + net.subtract(paid) + check((sum(paid.values()), sum(targets.values()), sum(r * n for r, n in net.items())) == (110519, 22461, 1424) + and r68["empty_root_credits"] == 0, "wrong complete invoice") + lo, hi = map(Q, admitted["crossing"]) + check((lo, hi) == tuple(map(Q, r68["new_raw_interval"])), "wrong exact crossing") + bit = Q(r68["bit_premise"]) + tariff = run_path(str(ROOT / "pricing.py")) + cost = tariff["cost"] + probe = hi + Q(1, 10**9) + prices, crossing_weights, target_weights = {}, {}, {} + for m in sorted(counts): + d = delta(m) + check(sum(d.values()) == 8 and sum(r * n for r, n in d.items()) == 0, "wrong paid count or rank mass") + candidate = signed_copy(net, d) + credit, target_credit = cost(d, hi), cost(d, TARGET) + margin, at_probe = cost(candidate, hi), cost(candidate, probe) + new_cost = cost({8 * m + 9: 8}, hi) + check(0 < credit[0] <= credit[1] < 1 and 0 < margin[0] and 0 < at_probe[0], "wrong price sign") + crossing_weights[m], target_weights[m] = credit[1], target_credit[1] + prices[m] = {"cases": counts[m], "paid_delta": {r: -n for r, n in d.items()}, + "credit": text(credit), "target_credit": text(target_credit), + "complete_margin_at_crossing_upper": text(margin), "complete_margin_at_probe": text(at_probe), + "break_even_volume_before_ancillary_cost": text( + (1 + margin[0] / new_cost[1], 1 + margin[1] / new_cost[0]))} + check(all(crossing_weights[a] < crossing_weights[a + 1] and target_weights[a] < target_weights[a + 1] + for a in range(1, 8)), "bad concave credit ordering") + on_old = best_matching(odd, even, crossing_weights) + on_target = best_matching(odd, even, target_weights) + best, match = max(on_old.values()) + target_upper, target_match = max(on_target.values()) + check(max(k.bit_count() for k in on_old) == len(match) == len(target_match) == 4, "wrong maximum stock") + check(sorted(len(even[c][1]) for _, c in match) == [7, 7, 8, 8], "wrong maximum price group") + whole_delta = Counter() + for _, e in target_match: + whole_delta.update(delta(len(even[e][1]))) + optimistic_target = cost(signed_copy(net, whole_delta), TARGET) + check(optimistic_target[1] < 0 and cost(net, probe)[1] < 0, "wrong incumbent or moonshot sign") + one_extra = signed_copy(net, delta(8)) + one_extra[1] -= 1 + derivative = run_path(str(ROOT / "derivative_check.py"))["derivative"](one_extra, lo, bit, tariff) + extra_margin = cost(one_extra, lo) + check(derivative[1] < 0 and extra_margin[1] < 0, "one edit paid debit not certified") + print(dumps({ + "head": HEAD, "caller_head": CALLER, "caller_sha256": PINS["7113-CALLER.json"], "inputs": PINS, + "crossing": [str(lo), str(hi)], "retained_BIT": str(bit), "moonshot": str(TARGET), + "complete_paid": paid, "complete_targets": targets, "ports": 8, "copies": 17, + "odd_jobs": odd, "even_jobs": even, "keys": keys, "prices_by_even_mask_size": prices, + "stock": len(keys), "odd_jobs_degrees": dict(Counter(r["odd"] for r in keys)), + "one_edit_optimistic_upper": str(crossing_weights[8]), "maximum_disjoint_pairs": 4, + "whole_compatible_upper": str(best), "whole_upper_matching": match, + "whole_upper_by_odd_mask": {mask: str(v[0]) for mask, v in on_old.items()}, + "old_margin_at_moonshot": text(cost(net, TARGET)), + "moonshot_whole_compatible_upper": str(target_upper), "moonshot_matching": target_match, + "moonshot_upper_full_margin": text(optimistic_target), "price_probe": str(probe), + "one_edit_extra_rank_one_margin_at_lower": text(extra_margin), + "one_edit_extra_rank_one_derivative_through_BIT": text(derivative), + "limits": {"first_cases": 180, "first_seconds": 20, "next_cases": 12, "next_seconds": 25, + "formal_cases": 2, "formal_seconds": 60, "physical_cases": 1, "physical_seconds": 90}, + "scope": "One same-volume signed union at the retained odd clock. Matching upper forbids repeated literal sites and grants all other compatibility and ancillary work free. No caller decoded.", + }, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-type-b-odd-even-idle-bound/receipts/MASK-ADMISSION.json b/research/p104-type-b-odd-even-idle-bound/receipts/MASK-ADMISSION.json new file mode 100644 index 0000000000..1a79990e19 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/receipts/MASK-ADMISSION.json @@ -0,0 +1,9 @@ +{ + "corrected_check": "exact role and unique stage-set equality", + "first_exit": 1, + "first_stopped_before_support": true, + "opposite_orders": 14, + "original_check": "ordered even-mask list equality", + "raw_first_stderr_sha256": "6082ca1a47bd02908d3e9ab7062a7b38d901e64f89b8577d620bbd49cff03e4a", + "scope_after_correction": 180 +} diff --git a/research/p104-type-b-odd-even-idle-bound/receipts/SHA256.json b/research/p104-type-b-odd-even-idle-bound/receipts/SHA256.json new file mode 100644 index 0000000000..da232d65c0 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/receipts/SHA256.json @@ -0,0 +1,5 @@ +{ + "INDEPENDENT.json": "afec20386a8fbdc70d1b96998adbe18edace42a3e14a015e0eab5c09fc311617", + "LEAD.json": "bf0cbae853422e85788449b40ddc2fa807b042d8a357a56a7c7654dda51331e4", + "PRICE.json": "33aad506112912ddf0721a2b007d9194eaa02e5792aceda2f9774f8838511262" +} diff --git a/research/p104-type-b-odd-even-idle-bound/replay.py b/research/p104-type-b-odd-even-idle-bound/replay.py new file mode 100644 index 0000000000..fc712ee2b4 --- /dev/null +++ b/research/p104-type-b-odd-even-idle-bound/replay.py @@ -0,0 +1,108 @@ +"""Replay exact pricing and both signed odd/even idle support exclusions.""" +from argparse import ArgumentParser +from fractions import Fraction +from gzip import decompress +from hashlib import sha1, sha256 +from json import loads +from pathlib import Path +from shutil import copytree +from subprocess import run +from sys import executable +from tempfile import TemporaryDirectory + +HERE = Path(__file__).resolve().parent +CALLER = "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" +BLOB = "9451ceaf6e8e037894680b549f3ef41c21b260d7" +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" + + +def check(ok, reason): + if not ok: + raise ValueError(reason) + + +def unique(items): + obj = dict(items) + check(len(obj) == len(items), "duplicate JSON path or key") + return obj + + +def decode(raw): + return loads(raw, object_pairs_hook=unique) + + +def digest(raw): + return sha256(raw).hexdigest() + + +def replay(output): + check(__debug__, "CPython assertions are required") + for rel, pin in decode((HERE / "LOCAL-PINS.json").read_bytes()).items(): + path = HERE / rel + check(path.resolve().is_relative_to(HERE) and digest(path.read_bytes()) == pin, f"changed input {rel}") + expected = decode((HERE / "receipts/SHA256.json").read_bytes()) + first = decode((HERE / "receipts/MASK-ADMISSION.json").read_bytes()) + caller = decompress((HERE / "price/inputs/7113-CALLER.json.gz").read_bytes()) + check(digest(caller) == CALLER and sha1(f"blob {len(caller)}".encode() + bytes(1) + caller).hexdigest() == BLOB, + "changed exact #7113 caller") + output.mkdir(parents=True, exist_ok=False) + with TemporaryDirectory(prefix="type-b-odd-even-") as tmp: + work = Path(tmp) + for name in ("inputs", "price", "lead", "independent"): + copytree(HERE / name, work / name) + inputs = work / "price/inputs" + for name in ("7113-CALLER.json", "R53-PRICE.json", "R59-PRICE.json"): + p = inputs / (name + ".gz") + p.with_suffix("").write_bytes(decompress(p.read_bytes())) + r53, r59 = (decode((inputs / name).read_bytes()) for name in ("R53-PRICE.json", "R59-PRICE.json")) + mask53 = {str(t): mask for t, _, mask in r53["job_masks"] if len(mask) > 1} + mask59 = {t: mask for t, (_, mask) in r59["even_jobs"].items()} + check(mask53.keys() == mask59.keys() and all(sorted(mask53[t]) == sorted(mask59[t]) for t in mask53) and + sum(mask53[t] != mask59[t] for t in mask53) == first["opposite_orders"] == 14, + "mask admission control differs") + + def stage(name, script, *args): + child = run([executable, "-I", "-B", str(script), *map(str, args)], cwd=work, + capture_output=True, check=True, timeout=25) + check(digest(child.stdout) == expected[name], "changed receipt " + name) + (output / name).write_bytes(child.stdout) + return decode(child.stdout) + + price = stage("PRICE.json", work / "price/quote.py") + price_path = work / "price/PRICE.json" + price_path.write_bytes((output / "PRICE.json").read_bytes()) + lead = stage("LEAD.json", work / "lead/projector_gate.py", work) + args = ("--price", price_path, "--admission", inputs / "7334-ADMITTED.json", + "--caller", inputs / "7113-CALLER.json") + second = stage("INDEPENDENT.json", work / "independent/direct_impulse.py", *args) + check(price["head"] == lead["head"] == second["head"] == HEAD and lead["q"] == second["q"] == 1 and + second["old_endpoint_columns"] == 36 and lead["counts"] == second["counts"] == {"excluded": 180} and + not any((lead["provisional"], lead["unvisited"], second["survivors"], second["unvisited"])), + "incomplete exact 180-case scope") + prime = lead["modulus"] + for key, left, right in zip(price["keys"], lead["decisions"], second["outcomes"], strict=True): + axis, col, coefficient = right["exact_off_axis"] + q = Fraction(coefficient) + residue = q.numerator * pow(q.denominator, -1, prime) % prime + check(left["key"] == key and right["key"] == [key["odd"], key["even"]] and + right["mask_size"] == key["size"] and axis == "column" and + left["outside_column"] == [col - 36, residue] and residue != 0, + "rational and modular witnesses differ") + (inputs / "7113-CALLER.json").write_bytes(caller + b" ") + mutant = run([executable, "-I", "-B", str(work / "independent/direct_impulse.py"), *map(str, args)], + cwd=work, capture_output=True, timeout=20) + check(mutant.returncode and b"changed input 7113-CALLER.json" in mutant.stderr and not mutant.stdout, + "changed caller accepted") + check({p.name for p in output.iterdir()} == set(expected), "wrong output set") + print("PASS_TYPE_B_ODD_EVEN_IDLE_FUSION cases=180 excluded=180 unresolved=0 kappa_change=0") + + +if __name__ == "__main__": + p = ArgumentParser() + p.add_argument("--out", type=Path) + a = p.parse_args() + if a.out: + replay(a.out.resolve()) + else: + with TemporaryDirectory(prefix="type-b-odd-even-receipts-") as tmp: + replay(Path(tmp) / "out")