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 8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9 Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Thu, 12 Nov 2026 04:22:03 -0800 Subject: [PATCH 3/3] Bound affine packing for the stage-17 parity shell --- .../LOCAL-PINS.json | 17 + .../NOTICE | 4 + .../PROOF.md | 23 + .../PROVENANCE.json | 102 + .../README.md | 28 + .../SOURCES.json | 18 + .../TASK.json | 117 + .../VERIFICATION.md | 5 + .../VERIFY.json | 14 + .../engines/independent.py | 194 ++ .../engines/lead.py | 91 + .../inputs/7113-SHA256.json | 69 + .../inputs/7113-signed-child.py | 146 + .../inputs/7397-PROOF.md | 110 + .../inputs/CALLER.json | 1 + .../inputs/PHYSICAL-BINDING.json | 64 + .../inputs/PR7362-SHA256.json | 11 + .../inputs/PROJECTOR.json | 104 + .../inputs/R173-INDEPENDENT.json | 88 + .../inputs/R92-PRICE.json | 2539 +++++++++++++++++ .../inputs/pricing.py | 82 + .../receipts/INDEPENDENT.json | 160 ++ .../receipts/LEAD.json | 61 + .../replay.py | 123 + 24 files changed, 4171 insertions(+) create mode 100644 research/p104-stage17-parity-shell-affine-bound/LOCAL-PINS.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/NOTICE create mode 100644 research/p104-stage17-parity-shell-affine-bound/PROOF.md create mode 100644 research/p104-stage17-parity-shell-affine-bound/PROVENANCE.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/README.md create mode 100644 research/p104-stage17-parity-shell-affine-bound/SOURCES.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/TASK.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/VERIFICATION.md create mode 100644 research/p104-stage17-parity-shell-affine-bound/VERIFY.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/engines/independent.py create mode 100644 research/p104-stage17-parity-shell-affine-bound/engines/lead.py create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/7113-SHA256.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/7113-signed-child.py create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/7397-PROOF.md create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/CALLER.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/PHYSICAL-BINDING.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/PR7362-SHA256.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/PROJECTOR.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/R173-INDEPENDENT.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/R92-PRICE.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/inputs/pricing.py create mode 100644 research/p104-stage17-parity-shell-affine-bound/receipts/INDEPENDENT.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/receipts/LEAD.json create mode 100644 research/p104-stage17-parity-shell-affine-bound/replay.py diff --git a/research/p104-stage17-parity-shell-affine-bound/LOCAL-PINS.json b/research/p104-stage17-parity-shell-affine-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..7ec5e26a06 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/LOCAL-PINS.json @@ -0,0 +1,17 @@ +{ + "PROVENANCE.json": "6520242a8aa8090d19a062d41d7681f3529e2ee85fe69a44ca1b100168c08823", + "engines/independent.py": "2c7a1aeae6df2bf2272a082d358178047c7c117065c1bb30e811a970c04a241e", + "engines/lead.py": "8401686f5e705415b2ed8646d1e3ac5f99a3a8378a6b069245c4352c17e11050", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/7397-PROOF.md": "1b5f670a1fd044b92905639b2cfb81eaf71c1dcdf63c114b73d2841919c58e32", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "inputs/PR7362-SHA256.json": "2c90ca39b0f075cc4b3ec9e90c66fde473465e7bb50cf1db9a820d3a29556c0b", + "inputs/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/R173-INDEPENDENT.json": "d53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/INDEPENDENT.json": "435620f25a7f15c2d67a0a511e6d7d699b0cfb307a0fd053c09d84dbe8ac1bbb", + "receipts/LEAD.json": "95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26" +} diff --git a/research/p104-stage17-parity-shell-affine-bound/NOTICE b/research/p104-stage17-parity-shell-affine-bound/NOTICE new file mode 100644 index 0000000000..11977c1ff2 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/NOTICE @@ -0,0 +1,4 @@ +Apache-2.0 contribution. Clear1nsight supplied the exact #7334 comparison. +Rohan Arun supplied the exact signed caller and physical gate in #7113. +See README.md and PROVENANCE.json for predecessor and tariff credits. +OpenAI Codex and subagents materially assisted proof and independent replay. diff --git a/research/p104-stage17-parity-shell-affine-bound/PROOF.md b/research/p104-stage17-parity-shell-affine-bound/PROOF.md new file mode 100644 index 0000000000..f7da47b2a1 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/PROOF.md @@ -0,0 +1,23 @@ +# A changed erased map and its affine volume + +At the exact Type B clocks 4646 and 4660 the #7113 word uses stage-17 IDLE_ONE on role 36. Let M be the scalar window of 13 literal events between the idles. Normalizing the old word on the left by M inverse produces I+P⊗(D−I), where P is the sum of the two complementary rank-one projectors and D is the stage-17 body. The independent engine recomputes M and its inverse, checks both zero corner entries and orthogonality, and matches the rank-two P to exact #7406. Both dirty lanes are independent in the range of P. + +On the selected axes 137 through 144, let m=8f for integral width f≥1. The physical body is D=C^⊗m, with C equal to the symmetric Gaussian matrix with diagonal (1+i)/2 and off-diagonal (1−i)/2. It acts as identity on parked axes. The binary square C² is the bit flip, so X=D² is translation by the all-ones vector on these m bits. Define + +```text +E = ((1+i)I + (1−i)X)/2. +``` + +Grant the changed erased map I+P⊗(E−I) and all its work free. The normalized residual that the core must supply is P⊗(D−E). In the common Walsh character with weight w, D acts by i^w and X acts by (−1)^w. E therefore acts by 1 on even w and i on odd w. The four forward residual eigenvalues in residues 0,1,2,3 are (0,0,−2,−2i), with (0,0,−2,+2i) for the adjoint. Transposing the rational P gives the role action of the normalized adjoint. The support in each input lane is exactly the weights 2 and 3 modulo four. + +At width one the two active residue counts are 56 and 64 per lane, giving 240 active lane/address pairs and raw residual volume 240/256=15/16 of one old lane. For general width, the roots-of-unity filter has (1+i)^m=(1−i)^m=2^(4f). The weight-2 residue count is 2^(m−2)−2^(4f−1) and the weight-3 count is 2^(m−2). The two-lane rank divided by one old lane volume is therefore 1−2^(−4f). + +## Affine chart and directed price + +In a fixed parked fibre the retained chart model routes one affine subset of the joint lane selector and common Walsh address, with arbitrary affine coordinate changes. To reproduce arbitrary residual inputs, its image must include every nonzero address in both lanes. An omitted coordinate carries an arbitrary input with nonzero required residual and cannot be restored by the granted fixed erased map. + +For every address bit j, choose two other distinct address bits. The weight-two point on them and its weight-three extension by bit j both lie in the residual support in the same lane. Their difference is the j-th unit vector. The same weight-two address in opposite lanes gives the lane-selector unit vector. This construction applies at every m=8f≥8 and shows that every containing affine chart has the full m+1 dimensions. Its size is 2^(m+1), exactly two old lane volumes. The full affine hull and this lower bound survive any invertible affine relabeling of the combined addresses. + +For one rank-16 core with charged volume ratio t, #7397’s conditional tariff gives gross 16H(8)−8tH(16) over the eight ports, with H(r)=r^(1−κ) and all other paid and productive terms fixed. A strict saving requires t<2^κ. The directed price at the old crossing bounds 2^κ above by 1.003. The hypothetical t=1 quote is about +0.320691708235 raw, while the required t=2 has upper below −126.39 raw. The exact rational intervals are in `receipts/LEAD.json`. Because H(16)>H(8) for 0<κ<1, the required t=2 cannot improve the paid moment anywhere in this range. + +The argument excludes one pure affine address chart for this exact parity erased map, fixed common Walsh fibres and conditional volume tariff. A non-affine extraction, multiple charts, mixed parked fibres, another erased map or a different tariff requires its own charged test. No physical parity shell, routed residual supplier or new recurrence was built. diff --git a/research/p104-stage17-parity-shell-affine-bound/PROVENANCE.json b/research/p104-stage17-parity-shell-affine-bound/PROVENANCE.json new file mode 100644 index 0000000000..c048726c39 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/PROVENANCE.json @@ -0,0 +1,102 @@ +{ + "comparator": { + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "pull_request": 7334, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334", + "status": "strongest independently reproduced complete comparable witness" + }, + "derived_inputs": { + "inputs/R92-PRICE.json": { + "key": "R92-PRICE.json", + "receipt": "inputs/PR7362-SHA256.json" + } + }, + "files": { + "inputs/7113-SHA256.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "5a7d6b80dc51aa918a5d521b60d18f9a6bbbc52e", + "path": "research/signed-caller-8x9/SHA256.json", + "sha256": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/SHA256.json" + }, + "inputs/7113-signed-child.py": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "0980a6559ba1939763de5c798c7947c8bdd51d67", + "path": "research/signed-caller-8x9/replay/supplier7112/short-caller/signed_child.py", + "sha256": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/replay/supplier7112/short-caller/signed_child.py" + }, + "inputs/7397-PROOF.md": { + "commit": "cd23b74fe48aa65b8007c1fd9af57246f4ebc2dd", + "git_blob": "782003175689310f0a97e59bde96fe12d8015603", + "path": "research/p104-fixed-type-b-two-return-provider-bound/PROOF.md", + "sha256": "1b5f670a1fd044b92905639b2cfb81eaf71c1dcdf63c114b73d2841919c58e32", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/cd23b74fe48aa65b8007c1fd9af57246f4ebc2dd/research/p104-fixed-type-b-two-return-provider-bound/PROOF.md" + }, + "inputs/CALLER.json": { + "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" + }, + "inputs/PHYSICAL-BINDING.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "c10f2a7f93b5632fb8789046b6a5c99da42c432a", + "path": "research/signed-caller-8x9/expected/ODD-PHYSICAL-BINDING.json", + "sha256": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/expected/ODD-PHYSICAL-BINDING.json" + }, + "inputs/PR7362-SHA256.json": { + "commit": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "git_blob": "b1486e0b5cfe4535f381ed26f7bce4aee21d8a43", + "path": "research/p104-rank-two-virtual-cut-bound/receipts/SHA256.json", + "sha256": "2c90ca39b0f075cc4b3ec9e90c66fde473465e7bb50cf1db9a820d3a29556c0b", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/5eec7ed633dcf9b9bbc95552aa653da296f863fb/research/p104-rank-two-virtual-cut-bound/receipts/SHA256.json" + }, + "inputs/PROJECTOR.json": { + "commit": "a5fa7b464a773afb47eb8b9725b94f660c407528", + "git_blob": "0c625fc6e1bbe38c3d9e0f35d8b37aafc167fce3", + "path": "research/p104-stage17-two-return-volume-bound/inputs/PROJECTOR.json", + "sha256": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a5fa7b464a773afb47eb8b9725b94f660c407528/research/p104-stage17-two-return-volume-bound/inputs/PROJECTOR.json" + }, + "inputs/R173-INDEPENDENT.json": { + "commit": "a5fa7b464a773afb47eb8b9725b94f660c407528", + "git_blob": "96cd7993b17b4e3e8f32a4caee3739959ee6671c", + "path": "research/p104-stage17-two-return-volume-bound/receipts/R173-INDEPENDENT.json", + "sha256": "d53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a5fa7b464a773afb47eb8b9725b94f660c407528/research/p104-stage17-two-return-volume-bound/receipts/R173-INDEPENDENT.json" + }, + "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" + } + }, + "predecessors": { + "7113": { + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "role": "Signed literal caller and binary Gaussian tensor gate.", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7113" + }, + "7362": { + "head": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "role": "Directed comparator stock and price.", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7362" + }, + "7397": { + "head": "cd23b74fe48aa65b8007c1fd9af57246f4ebc2dd", + "role": "Conditional volume-linear tariff.", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7397" + }, + "7406": { + "head": "a5fa7b464a773afb47eb8b9725b94f660c407528", + "role": "Exact pair, complementary rank-two projector, physical selected axes and previous identity erasure result.", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7406" + } + }, + "schema_version": 1 +} diff --git a/research/p104-stage17-parity-shell-affine-bound/README.md b/research/p104-stage17-parity-shell-affine-bound/README.md new file mode 100644 index 0000000000..01064a8772 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/README.md @@ -0,0 +1,28 @@ +# Bound affine packing for the stage-17 parity shell + +**Outcome** — Scoped exclusion. The complete bound is unchanged. + +For the exact Type B stage-17 returns at clocks 4646 and 4660, a parity-dependent erased map leaves only 240 active residual modes among 512 width-one lane/address pairs. Their rank is 15/16 of one old lane volume. Every one-chart affine route in the common Walsh addresses still needs two old lane volumes at every width. The hypothetical rank-16 volume tariff allows less than 1.003 old lane volumes at the incumbent. The eight-port gross upper is below −126.39 raw even with shell and ancillary work free. [Proof](PROOF.md) + +## Replay + +From a clean checkout on a POSIX host, use CPython 3.12 with assertions and its standard library. + +```sh +python3.12 -I -B research/p104-stage17-parity-shell-affine-bound/replay.py +``` + +Two exact engines authenticate the bundled sources and agree on the width-one residual support, affine dimension and price gate. The independent engine reconstructs the old literal projector and checks all 512 signed forward and adjoint cases. The wrapper rejects a changed caller. No network or external checkout is needed. Expected final line is `PASS_P104_STAGE17_PARITY_SHELL_AFFINE_BOUND`. [Verification](VERIFICATION.md) + +## Open next questions + +- Can non-affine routing or a disjoint chart cover isolate the same residual? Give one exact address extraction and price its total charged fields, indexing, ownership and restoration before building it. A small support rank alone does not supply that routing. +- Can a different erased map leave a residual with a smaller affine hull and a cheaper shell? Fix one exact map and test its signed action and whole paid price before scaling. + +## Predecessors + +- Clear1nsight’s #7334 `aaeec8c0acf01e99a5f331ef363a698d9c084ace` supplies the complete comparator, κ = 0.00364665195644. Rohan Arun’s #7113 `07a76c5e2738882c0cb322278e56f6cae3c9885d` supplies the literal caller and physical Gaussian gate. [Comparator PR](https://github.com/CrocSwap/integer-mult-bounds/pull/7334), [signed caller PR](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +- Exact #7406 `a5fa7b464a773afb47eb8b9725b94f660c407528` supplies the complementary projector, the retained axes and the previous identity-erased bound. This package tests the specified changed erasure. [Two-return predecessor](https://github.com/CrocSwap/integer-mult-bounds/pull/7406) +- #7397 supplies the conditional volume-linear tariff. #7362 and #7298 supply the directed price receipt and rational tariff lineage. Exact bytes and paths are in `PROVENANCE.json`. [Volume tariff](https://github.com/CrocSwap/integer-mult-bounds/pull/7397), [price receipt](https://github.com/CrocSwap/integer-mult-bounds/pull/7362), [price implementation](https://github.com/CrocSwap/integer-mult-bounds/pull/7298) + +OpenAI Codex and subagents materially assisted the proof, implementation and independent replay. diff --git a/research/p104-stage17-parity-shell-affine-bound/SOURCES.json b/research/p104-stage17-parity-shell-affine-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-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-stage17-parity-shell-affine-bound/TASK.json b/research/p104-stage17-parity-shell-affine-bound/TASK.json new file mode 100644 index 0000000000..ba44bccf83 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "One stage-17 parity erased map for the exact #7406 two-return pair at clocks 4646 and 4660, one affine chart in the common Walsh addresses and two lane selector values.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 stage-17 parity shell affine research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "A lower charged volume for both stage-17 returns could improve the binding paid moment, if a single rank-16 core can supply the residual after the parity shell.", + "budget_minutes": 10, + "evidence": "Both exact engines agree that 240 of 512 width-one lane/address pairs are active and their affine hull has all 9 dimensions. A constructive all-width witness gives required affine volume two old lanes. The directed rank-16 tariff allows less than 1.003 old lane volumes.", + "open_questions": [ + { + "blocked_by": "One affine input address chart spans both lanes at twice the old lane volume, above the price cap even before shell charges.", + "first_step": "Give one exact non-affine extraction or disjoint chart cover and price its combined field volumes, indexing and restoration under the retained compiler before a native build.", + "question": "Can a different residual routing provide the parity-shell residual with a lower charged volume?", + "why_it_matters": "The rank after erasure is below one old lane volume while the one-chart affine volume is exactly two." + } + ], + "original_card": { + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "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/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4133: literal-slot defect", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4136: uniform commutation gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4140: uniform encoding gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "status": "author-checked" + }, + { + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "status": "author-checked" + }, + { + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4154: fiber-tag seam mismatch", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "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": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "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": "p104-side-correction", + "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": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "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", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "Test the same exact complementary pair with a specified changed erased action and a one-chart affine residual route.", + "scope_status": "changed", + "stop_rule": "One parity shell and chart, both lanes, all 512 width-one addresses, exact forward/adjoint and 20 seconds per engine. Stop if the all-width hull exceeds the affordability bound.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-stage17-parity-shell-affine-bound/VERIFICATION.md b/research/p104-stage17-parity-shell-affine-bound/VERIFICATION.md new file mode 100644 index 0000000000..8bd6406620 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/VERIFICATION.md @@ -0,0 +1,5 @@ +# Verification + +The test covers the exact two stage-17 idles, two dirty lanes and all 512 width-one lane/address pairs, with a 20-second cap per engine. The lead checks complementary idempotents, residue counts, a constructive affine basis and both directed price intervals. The independent engine rebuilds the literal 13-event rational window and the physical P, checks the signed forward and adjoint binary gate, evaluates its exact tensor and parity residual on every width-one address, and computes the affine rank by GF(2) elimination. Both agree on 240 active addresses and affine rank nine. Discarding one lane lowers the independent control rank to eight. Restricting the residue to weight two lowers the lead control rank to eight. + +The clean wrapper regenerates the deterministic receipts, verifies the predecessor Git blob and SHA256 bindings, rejects duplicate JSON keys and rejects an altered stage mask at clock 4646 in both engines. The all-width result uses the constructive unit-direction proof rather than a width sweep. Scope is exhausted for this one affine-chart family. Multiple or non-affine routes and a physical compiler replay remain open. diff --git a/research/p104-stage17-parity-shell-affine-bound/VERIFY.json b/research/p104-stage17-parity-shell-affine-bound/VERIFY.json new file mode 100644 index 0000000000..d743c8e800 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Authenticate exact inputs, reproduce both signed affine-rank and directed price checks, and reject an altered caller.", + "timeout_seconds": 65 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-stage17-parity-shell-affine-bound/engines/independent.py b/research/p104-stage17-parity-shell-affine-bound/engines/independent.py new file mode 100644 index 0000000000..c5ccd325d3 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/engines/independent.py @@ -0,0 +1,194 @@ +"""Literal signed Gaussian replay and GF(2) affine-rank test for two return lanes.""" +import ast +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +HEAD = 'aaeec8c0acf01e99a5f331ef363a698d9c084ace' +CALLER = '07a76c5e2738882c0cb322278e56f6cae3c9885d' +PREDECESSOR = 'a5fa7b464a773afb47eb8b9725b94f660c407528' +PINS = { + 'inputs/PROJECTOR.json': 'c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35', + 'inputs/7113-signed-child.py': 'ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b', + 'inputs/R173-INDEPENDENT.json': 'd53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32', + 'inputs/CALLER.json': '255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', +} +CLOCKS, ROLES, M = (4646, 4660), (36, 37, 52, 53), 8 + + +def unique(pairs): + result = dict(pairs) + if len(result) != len(pairs): + raise ValueError('duplicate JSON key') + return result + + +def read(name): + raw = (ROOT/name).read_bytes() + assert sha256(raw).hexdigest() == PINS[name], name + return loads(raw, object_pairs_hook=unique) if name.endswith('.json') else raw + + +def mm(a, b): + return [[sum(x*y for x, y in zip(row, col, strict=True)) + for col in zip(*b, strict=True)] for row in a] + + +def identity(n): + return [[Q(i == j) for j in range(n)] for i in range(n)] + + +def inverse(a): + n = len(a) + m = [row + unit for row, unit in zip(a, identity(n), strict=True)] + for j in range(n): + i = next(i for i in range(j, n) if m[i][j]) + m[j], m[i] = m[i], m[j] + scale = m[j][j] + m[j] = [x/scale for x in m[j]] + for i in range(n): + if i != j: + scale = m[i][j] + m[i] = [x-scale*y for x, y in zip(m[i], m[j], strict=True)] + assert [row[:n] for row in m] == identity(n) + return [row[n:] for row in m] + + +def physical_projector(caller, old): + tape = caller['events'] + assert len(tape) == 4783 + assert all(tape[clock] == ['B','IDLE_ONE',36,[17]] for clock in CLOCKS) + m = identity(4) + for kind, op, dest, *args in tape[CLOCKS[0]+1:CLOCKS[1]]: + assert kind == 'B' and op in ('ADD','SCALE') + r = ROLES.index(dest) + if op == 'ADD': + src, value = args + m[r] = [x+Q(value)*y for x, y in zip(m[r], m[ROLES.index(src)], strict=True)] + else: + m[r] = [Q(args[0])*x for x in m[r]] + mi = inverse(m) + assert m[0][0] == mi[0][0] == 0 and mm(m,mi) == identity(4) + e = [[Q(i == j == 0) for j in range(4)] for i in range(4)] + f = mm(mm(mi,e),m) + assert not any(x for a in (mm(e,f),mm(f,e)) for row in a for x in row) + p = [[x+y for x, y in zip(a, b, strict=True)] for a, b in zip(e, f, strict=True)] + assert mm(p,p) == p and sum(p[i][i] for i in range(4)) == 2 + assert p == [[Q(x) for x in row] for row in old['projector']] + return p + + +def mul(a, b): + x,y = a + z,w = b + return x*z-y*w, x*w+y*z + + +def local_modes(gate, adjoint): + entries = [[(gate[j][i][0], -gate[j][i][1]) if adjoint else gate[i][j] + for j in range(2)] for i in range(2)] + modes = [] + for d in (0,1): + v = (1,(-1)**d) + image = [tuple(sum(v[j]*entries[i][j][k] for j in range(2)) for k in range(2)) + for i in range(2)] + real, imag = image[0] + assert real % 2 == imag % 2 == 0 + assert image[1] == (v[1]*real,v[1]*imag) + modes.append((real//2,imag//2)) + for i in range(2): + for j in range(2): + terms = [mul(entries[i][k],entries[k][j]) for k in range(2)] + assert tuple(map(sum,zip(*terms))) == (4*(i != j),0) + return modes + + +def residual(u, m, modes, adjoint): + d = (1,0) + for j in range(m): + d = mul(d,modes[(u>>j)&1]) + # Exact Walsh character of the all-ones translation. + x = (-1)**(u & ((1<= 8. A weight-2 word excluding j + # and its weight-3 extension differ by e_j; opposite lanes give the last bit. + direction_witnesses = [] + for j in range(M): + a,b = [i for i in range(M) if i != j][:2] + low = (1<=1; affine rank m+1; chart volume 2 old lanes', + 'discard_one_lane_control_rank':8,'runner_cap_seconds':20,'build_admitted':False}, + indent=2,sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-stage17-parity-shell-affine-bound/engines/lead.py b/research/p104-stage17-parity-shell-affine-bound/engines/lead.py new file mode 100644 index 0000000000..1b4c7d0599 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/engines/lead.py @@ -0,0 +1,91 @@ +"""Price a fixed affine chart after the two-return parity bypass.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT=Path(__file__).resolve().parent +PINS={ + "inputs/CALLER.json":"255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PROJECTOR.json":"c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/R92-PRICE.json":"05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py":"f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} + + +def rank(vectors): + basis={} + for x in vectors: + while x: + p=x.bit_length()-1 + if p not in basis: + basis[p]=x + break + x ^= basis[p] + return len(basis) + + +def mul(a,b): + return [[sum(x*y for x,y in zip(row,col,strict=True)) for col in zip(*b,strict=True)] for row in a] + + +def stop(*_): + raise TimeoutError("20-second affine hull gate") + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(20) + for path,digest in PINS.items(): + assert sha256((ROOT/path).read_bytes()).hexdigest()==digest + c=loads((ROOT/"inputs/CALLER.json").read_bytes()) + p=loads((ROOT/"inputs/PROJECTOR.json").read_bytes()) + price=loads((ROOT/"inputs/R92-PRICE.json").read_bytes()) + clocks=(4646,4660) + assert p["inclusive_window"]==list(clocks) and p["events"]==15 + assert p["head"]==price["head"] and p["caller"]==price["caller_head"] + assert all(c["events"][k]==["B","IDLE_ONE",36,[17]] for k in clocks) + ports=c["types"]["B"]["ports"] + assert ports==[15,17,27,34,35,42,47,55] + a,b=([[Q(x) for x in row] for row in mat] for mat in p["projectors"]) + assert mul(a,a)==a and mul(b,b)==b and mul(a,b)==mul(b,a)==[[0]*4 for _ in range(4)] + assert sum(a[i][i] for i in range(4))==sum(b[i][i] for i in range(4))==1 + cost=run_path(str(ROOT/"inputs/pricing.py"))["cost"] + k=Q(price["old_crossing_upper"]) + ideal=cost(Counter({8:16,16:-8}),k) + actual=cost(Counter({8:16,16:-16}),k) + p8=cost(Counter({8:2}),k) + p16=cost(Counter({16:1}),k) + assert 0> (a*width)) ^ (label >> (b*width))) & mask + return label ^ (delta << (a*width)) ^ (delta << (b*width)) + + +def permute(label, swaps, width): + for a, b in swaps: + label = swap_blocks(label, a, b, width) + return label + + +def masks(stage, width): + return ((1 << width)-1, ((1 << (8*width))-1) << ((9+8*(stage-1))*width)) + + +def descriptor(stage): + assert 1 <= stage <= 18 + return tuple((j, 8*stage+j) for j in range(1, 9)) + + +def packed_kernel(row, col, width, mutate=None): + if (row ^ col) >> (9*width): + return (0, 0) + result = (1, 0) + for j in range(9*width): + result = multiply(result, C[(row >> j) & 1][(col >> j) & 1]) + q = (1 << width)-1 + if (row ^ col) & q and ((row ^ col) & q).bit_count() % 2: + result = -result[0], -result[1] + exponent = width if mutate != 'missing multiplicity' else 1 + return multiply(PHASE[exponent % 4] if mutate != 'missing global phase' else (1,0), result) + + +def separate_kernel(row, col, stage, width): + q, body = masks(stage, width) + if (row ^ col) & ~(q | body): + return (0,0) + result = (1,0) + for bit in range(width): + result = multiply(result, conjugate(C[(row >> bit) & 1][(col >> bit) & 1])) + start = (9+8*(stage-1))*width + for bit in range(start, start+8*width): + result = multiply(result, C[(row >> bit) & 1][(col >> bit) & 1]) + return result + + +def verify_route(stage, width): + swaps = descriptor(stage) + q, body = masks(stage, width) + front = (1 << (9*width))-1 + assert permute(q | body, swaps, width) == front + assert permute(q, swaps, width) == q + for i in range(LAYOUT*width): + x = 1 << i + assert permute(permute(x, swaps, width), reversed(swaps), width) == x + return swaps + + +def check_finite(stage, width, rng): + swaps = verify_route(stage, width) + q, body = masks(stage, width) + prefix = 9*width + active = q | body + parked = rng.getrandbits(LAYOUT*width) & ~active + if width == 1: + pairs = ((r,c) for r in range(1<=1; affine rank m+1; chart volume 2 old lanes", + "build_admitted": false, + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "case_count": 512, + "clocks": [ + 4646, + 4660 + ], + "discard_one_lane_control_rank": 8, + "forward_residual_multiplicities_by_lane": [ + { + "(-2, 0)": 56, + "(0, -2)": 64, + "(0, 0)": 136 + }, + { + "(-2, 0)": 56, + "(0, -2)": 64, + "(0, 0)": 136 + } + ], + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "pins": { + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/R173-INDEPENDENT.json": "d53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32" + }, + "pr7406": "a5fa7b464a773afb47eb8b9725b94f660c407528", + "projector": [ + [ + "1", + "0", + "0", + "0" + ], + [ + "0", + "-1/4", + "-1/2", + "3/2" + ], + [ + "0", + "-1/8", + "-1/4", + "3/4" + ], + [ + "0", + "-1/4", + "-1/2", + "3/2" + ] + ], + "residual_modes_per_lane": 120, + "residual_modes_total": 240, + "residual_volume_old_lane": "15/16", + "runner_cap_seconds": 20, + "selected_axes": [ + 137, + 138, + 139, + 140, + 141, + 142, + 143, + 144 + ], + "unit_direction_witnesses": [ + [ + 0, + 6, + 7 + ], + [ + 1, + 5, + 7 + ], + [ + 2, + 3, + 7 + ], + [ + 3, + 3, + 11 + ], + [ + 4, + 3, + 19 + ], + [ + 5, + 3, + 35 + ], + [ + 6, + 3, + 67 + ], + [ + 7, + 3, + 131 + ], + [ + 8, + 3, + 259 + ] + ] +} diff --git a/research/p104-stage17-parity-shell-affine-bound/receipts/LEAD.json b/research/p104-stage17-parity-shell-affine-bound/receipts/LEAD.json new file mode 100644 index 0000000000..127ccbafa9 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/receipts/LEAD.json @@ -0,0 +1,61 @@ +{ + "active_width_one": 240, + "affine_chart_raw_gain": [ + "-19748697417970734618331203012957090447795028176069/156250000000000000000000000000000000000000000000", + "-78994789671882938473324812051828361791180112704273/625000000000000000000000000000000000000000000000" + ], + "affine_hull_dimension": 9, + "affine_minimum_volume_fraction": 2, + "affine_points": [ + 3, + 5, + 9, + 17, + 33, + 65, + 129, + 6, + 7, + 259 + ], + "all_width_active_volume_fraction_of_one_lane": "1-2^(-4f)", + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "clocks": [ + 4646, + 4660 + ], + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "ideal_one_lane_raw_gain": [ + "80172927058770620952479414571084013672836750621/250000000000000000000000000000000000000000000000", + "400864635293853104762397072855420068364183753109/1250000000000000000000000000000000000000000000000" + ], + "phase_counts": { + "0": 72, + "1": 64, + "2": 56, + "3": 64 + }, + "pins": { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182" + }, + "ports": [ + 15, + 17, + 27, + 34, + 35, + 42, + 47, + 55 + ], + "rank16_affordability": [ + "52930436204784527718724806083122521239696197638254/52796814659686576683804007058837381216908136387219", + "158791308614353583156174418249367563719088592914764/158390443979059730051412021176512143650724409161655" + ], + "runner_cap_seconds": 20, + "selected_bits": 8, + "width_one_addresses": 512 +} diff --git a/research/p104-stage17-parity-shell-affine-bound/replay.py b/research/p104-stage17-parity-shell-affine-bound/replay.py new file mode 100644 index 0000000000..08c0a38119 --- /dev/null +++ b/research/p104-stage17-parity-shell-affine-bound/replay.py @@ -0,0 +1,123 @@ +"""Replay two exact stage-17 parity-shell affine chart obstructions.""" +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from json import dumps, loads +from pathlib import Path +from subprocess import run +import sys +from tempfile import TemporaryDirectory + +ROOT = Path(__file__).resolve().parent + + +def unique(pairs): + result = dict(pairs) + if len(result) != len(pairs): + raise ValueError("duplicate JSON key") + return result + + +def source(name): + path = (ROOT / name).resolve() + assert path.is_relative_to(ROOT) and path.relative_to(ROOT).as_posix() == name + return path.read_bytes() + + +def decode(raw): + return loads(raw, object_pairs_hook=unique) + + +def digest(raw): + return sha256(raw).hexdigest() + + +def authenticate(): + pins = decode(source("LOCAL-PINS.json")) + for name, expected in pins.items(): + raw = source(name) + assert digest(raw) == expected, name + if name.endswith(".json"): + decode(raw) + prov = decode(source("PROVENANCE.json")) + for name, entry in prov["files"].items(): + raw = source(name) + assert digest(raw) == entry["sha256"] + assert sha1(f"blob {len(raw)}\0".encode() + raw).hexdigest() == entry["git_blob"] + price = prov["derived_inputs"]["inputs/R92-PRICE.json"] + assert decode(source(price["receipt"]))[price["key"]] == pins["inputs/R92-PRICE.json"] + signed = decode(source("inputs/7113-SHA256.json")) + for name, key in (("CALLER.json", "expected/ODD-TYPE-AB-CALLER.json"), + ("PHYSICAL-BINDING.json", "expected/ODD-PHYSICAL-BINDING.json"), + ("7113-signed-child.py", "replay/supplier7112/short-caller/signed_child.py")): + assert signed[key] == pins["inputs/" + name] + binding = decode(source("inputs/PHYSICAL-BINDING.json")) + assert binding["caller_sha256"] == pins["inputs/CALLER.json"] + assert binding["occurrence_and_geometry"]["ambient"] == 145 + + +def execute(tmp, script, receipt=None): + result = run([sys.executable, "-I", "-B", str(tmp / script)], capture_output=True, timeout=22) + if receipt is None: + assert result.returncode == 1 and not result.stdout and b"AssertionError" in result.stderr + return None + if result.returncode: + sys.stderr.write(result.stderr.decode(errors="replace")) + result.check_returncode() + assert result.stdout == source("receipts/" + receipt), receipt + return decode(result.stdout) + + +def compare(lead, independent): + assert lead["head"] == independent["head"] == "aaeec8c0acf01e99a5f331ef363a698d9c084ace" + assert lead["caller"] == independent["caller"] == "07a76c5e2738882c0cb322278e56f6cae3c9885d" + assert independent["pr7406"] == "a5fa7b464a773afb47eb8b9725b94f660c407528" + assert lead["clocks"] == independent["clocks"] == [4646, 4660] + assert lead["width_one_addresses"] == independent["case_count"] == 512 + assert lead["active_width_one"] == independent["residual_modes_total"] == 240 + assert lead["affine_hull_dimension"] == independent["affine_rank"] == 9 + assert independent["discard_one_lane_control_rank"] == 8 + assert independent["selected_axes"] == list(range(137, 145)) + assert lead["affine_minimum_volume_fraction"] == Q(independent["affine_chart_old_lane_volume"]) == 2 + phases = lead["phase_counts"] + assert independent["forward_residual_multiplicities_by_lane"] == [ + {"(0, 0)": phases["0"] + phases["1"], "(-2, 0)": phases["2"], "(0, -2)": phases["3"]}] * 2 + assert Q(independent["residual_volume_old_lane"]) == Q(15, 16) + lo, hi = map(Q, lead["rank16_affordability"]) + assert hi == Q(independent["affordability_upper"]) + assert 1 < lo <= hi < Q("1.003") + low, high = map(Q, lead["ideal_one_lane_raw_gain"]) + assert Q("0.320") < low <= high < Q("0.321") + low, high = map(Q, lead["affine_chart_raw_gain"]) + assert low <= high < Q("-126.39") + assert not independent["build_admitted"] + + +def main(): + if sys.implementation.name != "cpython" or sys.version_info[:2] != (3, 12) or not __debug__: + raise SystemExit("CPython 3.12 with assertions is required") + authenticate() + with TemporaryDirectory(prefix="p104-stage17-parity-shell-") as name: + tmp = Path(name) + (tmp / "inputs").mkdir() + for path in (ROOT / "inputs").iterdir(): + (tmp / "inputs" / path.name).write_bytes(source("inputs/" + path.name)) + for engine in ("lead.py", "independent.py"): + (tmp / engine).write_bytes(source("engines/" + engine)) + lead = execute(tmp, "lead.py", "LEAD.json") + independent = execute(tmp, "independent.py", "INDEPENDENT.json") + compare(lead, independent) + caller_path = tmp / "inputs/CALLER.json" + caller = decode(caller_path.read_bytes()) + caller["events"][4646][3] = [16] + caller_path.write_text(dumps(caller), encoding="utf-8") + execute(tmp, "lead.py") + execute(tmp, "independent.py") + print(dumps({"checked_addresses": 512, "residual_addresses": 240, "affine_rank": 9, + "old_lane_volume_required": "2", "affordability_below": "1.003", + "eight_port_gross_upper_below": "-126.39", "corrupt_caller_rejected": True, + "kappa_delta": "0"}, sort_keys=True)) + print("PASS_P104_STAGE17_PARITY_SHELL_AFFINE_BOUND") + + +if __name__ == "__main__": + main()