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 a3980ce0ab8889b29c9f5621db144e23f6d0f256 Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Thu, 12 Nov 2026 06:44:02 -0800 Subject: [PATCH 3/3] Bound parity-sketch erasure of two stage-17 body lanes --- .../LOCAL-PINS.json | 16 ++ .../NOTICE | 2 + .../PROOF.md | 23 ++ .../PROVENANCE.json | 101 +++++++ .../README.md | 27 ++ .../SOURCES.json | 18 ++ .../TASK.json | 117 ++++++++ .../VERIFICATION.md | 5 + .../VERIFY.json | 14 + .../engines/independent.py | 178 ++++++++++++ .../engines/lead.py | 77 +++++ .../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/PROJECTOR.json | 104 +++++++ .../inputs/pricing.py | 82 ++++++ .../receipts/INDEPENDENT.json | 160 +++++++++++ .../receipts/LEAD.json | 61 ++++ .../receipts/R215-INDEPENDENT.json | 267 ++++++++++++++++++ .../receipts/R215-LEAD.json | 32 +++ .../replay.py | 102 +++++++ 23 files changed, 1776 insertions(+) create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/LOCAL-PINS.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/NOTICE create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/PROOF.md create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/PROVENANCE.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/README.md create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/SOURCES.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/TASK.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/VERIFICATION.md create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/VERIFY.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/engines/independent.py create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/engines/lead.py create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-SHA256.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-signed-child.py create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/7397-PROOF.md create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/CALLER.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/PHYSICAL-BINDING.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/PROJECTOR.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/inputs/pricing.py create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/receipts/INDEPENDENT.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/receipts/LEAD.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-INDEPENDENT.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-LEAD.json create mode 100644 research/p104-stage17-parity-sketch-erasure-bound/replay.py diff --git a/research/p104-stage17-parity-sketch-erasure-bound/LOCAL-PINS.json b/research/p104-stage17-parity-sketch-erasure-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..0302433eda --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/LOCAL-PINS.json @@ -0,0 +1,16 @@ +{ + "PROVENANCE.json": "546f6356f3991175effa6e44520154a298f31917f06fd8ed2a97992ac53e504e", + "engines/independent.py": "3730b8e2f580abd27cfa3d3de88c40aca36b72ae6eeafaeb5d1fbe5870163df9", + "engines/lead.py": "235a691e9f54150d9aef756785a5e58b74396dbb6605c4d353f63ca8b8b312c3", + "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/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/INDEPENDENT.json": "435620f25a7f15c2d67a0a511e6d7d699b0cfb307a0fd053c09d84dbe8ac1bbb", + "receipts/LEAD.json": "95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26", + "receipts/R215-INDEPENDENT.json": "974b050043ed5e1b2d84da284c4e071417993d43cebb6b1ca335a5e12242ae6b", + "receipts/R215-LEAD.json": "bb56aba37b614642e61f0028b6d48b41625cf234d9f7a470824d3c06e4acf32c" +} diff --git a/research/p104-stage17-parity-sketch-erasure-bound/NOTICE b/research/p104-stage17-parity-sketch-erasure-bound/NOTICE new file mode 100644 index 0000000000..b815791e2f --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/NOTICE @@ -0,0 +1,2 @@ +Apache-2.0 contribution. See README.md and PROVENANCE.json for exact predecessor and tariff credits. +OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging. diff --git a/research/p104-stage17-parity-sketch-erasure-bound/PROOF.md b/research/p104-stage17-parity-sketch-erasure-bound/PROOF.md new file mode 100644 index 0000000000..854edf0555 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/PROOF.md @@ -0,0 +1,23 @@ +# Five linear parities leave an exact capacity gap + +The #7416 predecessor fixes the exact two stage-17 returns at clocks 4646 and 4660 in #7113. The intervening 13 ordinary operations have an invertible scalar matrix. The corresponding rank-one lane projectors are complementary, so the old normalized operator on their common range is the scalar `D` on both independent dirty lanes. The independent replay reconstructs the two-lane projector by applying the actual scalar interval and inverse on all four basis columns. The stage body acts as `C^(8f)`, with binary C eigenvalues 1 and i on the plus and minus Walsh characters. Set `f=2`, `m=16`, `N=2^m`, and work in the fixed common Walsh addresses. The target at address x is `i^w I₂`, where w is the Hamming weight of x. + +## Occupancy of a parity cell + +The two bits of w modulo four are `p(x)=w mod 2` and `Q(x)=binom(w,2) mod 2`. The polar form of Q is `B(x,y)=p(x)p(y)+x·y`, with alternating matrix `I+J` over GF(2), where J is the all-ones matrix. Since m is even, J²=0 and `(I+J)²=I`. The form is nondegenerate. + +At most five linear probes give cells that are affine cosets `v+W`, where W has codimension k≤5. Nondegeneracy gives `dim W⊥=k`. The restriction radical `W∩W⊥` has dimension at most k, so the restriction rank is at least `m−2k≥6`. The squared quadratic-character mean on a cell is a sum over differences h∈W. For each h, averaging the polar character `(-1)^B(x,h)` over x∈W gives zero unless h is in the restriction radical. The remaining terms have magnitude one. The squared mean is therefore at most `2^(-rank(B|W))≤1/64`. Thus the absolute bias is at most 1/8 and each value of Q has occupancy at most 9/16. Every phase of `i^w` specifies a value of Q, so every phase has occupancy at most 9/16 in each cell. + +The one explicit control uses total parity plus the parities of four disjoint pairs on the first eight bits. Its restriction rank is six. Independent direct counting covers all 32 cells and all 65,536 addresses and attains phase occupancy 9/16 in cell 30. That single sketch would in fact require residual rank 65,280 after its optimal erased matrix choices. The universal bound uses the worst possible phase occupancy in every cell. + +## Erased matrix and normalized core + +Let E be any complex 2×2 erased matrix for a cell, without an invertibility or normality requirement. The eigenspaces at the four distinct target phases have dimensions whose sum is at most two. The cell's matched dimension is the phase-count weighted sum of those eigenspace dimensions. The maximum occupancy bound puts it at most `2(9/16)` times the number of addresses in the cell. Summing over cells, the old target minus erasure has rank at least `2N−(9/8)N=7N/8`. + +Grant arbitrary fixed linear routes around the one changed normalized core. Write the actual map as `B₀+F C_core E₀` and its erased version as `B₀+F E₀`. Their difference is `F(C_core−I)E₀`, with rank at most the core's displacement. A normalized rank-16 core at f=2 has 32 independent binary C factors. The exact mod-four binomial count gives an eigenvalue-one fraction `32769/131072>1/4`, so the displacement capacity on t old lane volumes is at most `3tN/4`. Consequently `t≥7/6` is necessary. A rank-zero core has no displacement. + +## Directed price and scope + +The inherited conditional tariff removes `16H(8)` and adds `8tH(16)` over eight ports, where `H(r)=r^(1−κ)`. The directed lead replay uses the incumbent crossing interval to bound the funded volume above by approximately 1.0025308637644, strictly below 1.003. With t≥7/6, the resulting optimistic gross upper is below −20.798 raw before all ancillary charges. See the exact rational result in `receipts/R215-LEAD.json`. + +This excludes only the stated width-two fixed-fibre family with at most five linear parity probes, one normalized rank-16 core and the inherited volume tariff. The erased matrices can mix both lanes within each cell. Mixed Walsh addresses, more probes, nonlinear dependence, a changed core or a different tariff need their own proof. No native supplier was built. diff --git a/research/p104-stage17-parity-sketch-erasure-bound/PROVENANCE.json b/research/p104-stage17-parity-sketch-erasure-bound/PROVENANCE.json new file mode 100644 index 0000000000..a8d9df093d --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/PROVENANCE.json @@ -0,0 +1,101 @@ +{ + "comparator": { + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "pull_request": 7334, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334", + "status": "strongest independently reproduced complete comparable witness" + }, + "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/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/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" + }, + "receipts/INDEPENDENT.json": { + "commit": "8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9", + "git_blob": "4484ef4c62f890b95300fd363cc188b08275bbd5", + "path": "research/p104-stage17-parity-shell-affine-bound/receipts/INDEPENDENT.json", + "sha256": "435620f25a7f15c2d67a0a511e6d7d699b0cfb307a0fd053c09d84dbe8ac1bbb", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9/research/p104-stage17-parity-shell-affine-bound/receipts/INDEPENDENT.json" + }, + "receipts/LEAD.json": { + "commit": "8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9", + "git_blob": "127ccbafa9772887842178490d1736c68db5074c", + "path": "research/p104-stage17-parity-shell-affine-bound/receipts/LEAD.json", + "sha256": "95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9/research/p104-stage17-parity-shell-affine-bound/receipts/LEAD.json" + } + }, + "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" + }, + "7416": { + "head": "8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9", + "role": "Exact parity-shell window, physical binding and directed volume receipts.", + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7416" + } + }, + "schema_version": 1 +} diff --git a/research/p104-stage17-parity-sketch-erasure-bound/README.md b/research/p104-stage17-parity-sketch-erasure-bound/README.md new file mode 100644 index 0000000000..eaee7fb27a --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/README.md @@ -0,0 +1,27 @@ +# Bound parity-sketch erasure of two stage-17 body lanes + +**Outcome.** Scoped exclusion. The complete bound is unchanged. + +Fix the two Type B stage-17 returns at clocks 4646 and 4660 on the exact #7334/#7113 construction. At width two, allow an arbitrary 2×2 erased matrix in each common Walsh-address cell selected by at most five linear parity probes. Even with free linear routing and erasure, the two dirty lanes require displacement rank at least seven eighths of one old lane volume. A single normalized rank-16 core requires volume at least 7/6 under this bound. The directed tariff funds less than 1.003 volumes. Its eight-port optimistic gross upper is below −20.798 raw. [Proof](PROOF.md) + +## Replay + +Use CPython 3.12 with assertions on POSIX. From the checkout root: + +```sh +python3.12 -I -B research/p104-stage17-parity-sketch-erasure-bound/replay.py +``` + +Both exact engines use the standard library. The replay authenticates bundled source and receipts, reconstructs one exact extremal sketch over all 65,536 addresses, verifies the directed price, and rejects a changed literal caller. Expected output is `PASS_P104_STAGE17_PARITY_SKETCH_ERASURE_BOUND`. [Verification](VERIFICATION.md) + +## Open next questions + +The five-probe bound leaves erasures with more linear probes, nonlinear dependence, or cross-address mixing open. Before a build, specify one actual erased matrix family and its routing, reconstruct the exact residual capacity, then charge all field, setup, restoration, precision and tape costs. For a six-probe follow-up at the same width, start with the strengthened polar rank bound and test one concrete extremal sketch only if its full tariff can still improve. + +## Predecessors + +- #7334 and #7113 supply the exact native comparator, literal signed caller and binary Gaussian tensor factor. [Comparator](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) · [Caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +- #7406 supplies the two complementary return lanes. #7416 constructs a single parity shell and prices one affine extraction. This package uses arbitrary lane mixing within each cell of a bounded linear Walsh sketch. [Two-return volume](https://github.com/CrocSwap/integer-mult-bounds/pull/7406) · [Parity shell](https://github.com/CrocSwap/integer-mult-bounds/pull/7416) +- #7397 supplies the conditional volume tariff. #7362 and #7298 supply directed accounting and its implementation. [Tariff](https://github.com/CrocSwap/integer-mult-bounds/pull/7397) · [Directed stock](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) · [Arithmetic](https://github.com/CrocSwap/integer-mult-bounds/pull/7298) + +OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging. diff --git a/research/p104-stage17-parity-sketch-erasure-bound/SOURCES.json b/research/p104-stage17-parity-sketch-erasure-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-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-sketch-erasure-bound/TASK.json b/research/p104-stage17-parity-sketch-erasure-bound/TASK.json new file mode 100644 index 0000000000..00383880ae --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "One exact stage-17 two-return capacity test at width two, erasure depending on at most five linear parities in a fixed common Walsh address, one normalized rank-16 core.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 stage-17 parity sketch 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 every parity cell has any phase occupancy at most 9/16. The one extremal sketch attains it. Required volume is at least 7/6, above the directed tariff below 1.003.", + "open_questions": [ + { + "blocked_by": "No six-parity shell or alternative charged core is constructed here.", + "first_step": "Pin one exact six-parity shell and derive its complete residual rank, affine extraction volume, tape and price before a native build.", + "question": "Can a richer Walsh shell beat the complete charged volume?", + "why_it_matters": "The five-parity bound leaves higher parity rank and arbitrary Walsh dependence open." + } + ], + "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 low-information Walsh-dependent erased matrices, a distinct mechanism from the exact parity shell and its affine extraction.", + "scope_status": "changed", + "stop_rule": "One exact pair at width two, one extremal sketch over 65,536 addresses, 20 seconds per engine. Stop at an exact paid capacity gap.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-stage17-parity-sketch-erasure-bound/VERIFICATION.md b/research/p104-stage17-parity-sketch-erasure-bound/VERIFICATION.md new file mode 100644 index 0000000000..0ee05cc052 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/VERIFICATION.md @@ -0,0 +1,5 @@ +# Verification + +The lead replay authenticates the exact caller, rank-two predecessor projector and directed price implementation. It verifies the full polar rank, runs the one extremal five-probe control, checks the binomial core and reproduces the exact directed gross upper. The independent replay authenticates seven path-keyed inputs, reconstructs the literal scalar interval and both return projectors, checks the Gaussian eigenvectors, eliminates the restricted polar form independently and counts all 32 parity cells. Both agree on a maximum phase occupancy of 9/16, core fixed fraction 32769/131072 and required volume 7/6. The independent result also records the exact 32-cell phase histogram and the optimal residual dimension for this one control. + +The 20-second cap per engine covers one width, one literal pair and one extremal sketch. The independent engine took 0.07 elapsed runner seconds and exited 0. The wrapper regenerates the byte-exact lead and independent results and checks the source hashes and Git blob identities. It rejects changing stage 17 to 16 at the first selected clock. The clean command needs no prior temporary state, network or external checkout. The mathematical cell argument covers all linear probes of rank at most five, while the enumeration checks one extremal control. No changed native, fixed-tape, precision or recurrence replay was triggered. diff --git a/research/p104-stage17-parity-sketch-erasure-bound/VERIFY.json b/research/p104-stage17-parity-sketch-erasure-bound/VERIFY.json new file mode 100644 index 0000000000..0e32f75ae3 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Authenticate inputs, replay both exact parity-sketch engines, verify the directed tariff, 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-sketch-erasure-bound/engines/independent.py b/research/p104-stage17-parity-sketch-erasure-bound/engines/independent.py new file mode 100644 index 0000000000..315b1b0596 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/engines/independent.py @@ -0,0 +1,178 @@ +"""Exact independent width-two five-parity sketch capacity check.""" +from ast import Assign, Name, literal_eval, parse +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 +from sys import argv, implementation, version_info + +CAP = 20 +F = 2 +M = 8 * F +HEAD = 'aaeec8c0acf01e99a5f331ef363a698d9c084ace' +CALLER = '07a76c5e2738882c0cb322278e56f6cae3c9885d' +PREDECESSOR = '8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9' +CLOCKS = (4646, 4660) +ROLES = (36, 37, 52, 53) +PINS = { + 'inputs/7113-SHA256.json': '064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078', + 'inputs/7113-signed-child.py': 'ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b', + 'inputs/CALLER.json': '255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', + 'inputs/PHYSICAL-BINDING.json': 'ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5', + 'inputs/7397-PROOF.md': '1b5f670a1fd044b92905639b2cfb81eaf71c1dcdf63c114b73d2841919c58e32', + 'receipts/INDEPENDENT.json': '435620f25a7f15c2d67a0a511e6d7d699b0cfb307a0fd053c09d84dbe8ac1bbb', + 'receipts/LEAD.json': '95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26', +} + + +def no_duplicates(items): + obj = dict(items) + assert len(obj) == len(items) + return obj + + +def pin(root, path): + raw = (root / path).read_bytes() + assert sha256(raw).hexdigest() == PINS[path], path + return loads(raw, object_pairs_hook=no_duplicates) if path.endswith('.json') else raw + + +def unit(j): + return [Q(i == j) for i in range(4)] + + +def run_scalar(events, x, inverse=False): + x = x.copy() + for kind, op, role, *args in reversed(events) if inverse else events: + assert kind == 'B' + dst = ROLES.index(role) + if op == 'ADD': + src, weight = args + x[dst] += Q(weight) * (-1 if inverse else 1) * x[ROLES.index(src)] + else: + assert op == 'SCALE' + x[dst] *= Q(args[0]) ** (-1 if inverse else 1) + return x + + +def stage(caller, previous): + events = caller['events'] + a, b = CLOCKS + assert len(events) == 4783 and all(events[i] == ['B', 'IDLE_ONE', 36, [17]] for i in CLOCKS) + between = events[a+1:b] + assert len(between) == 13 + forward = [run_scalar(between, unit(j)) for j in range(4)] + backward = [run_scalar(between, unit(j), inverse=True) for j in range(4)] + assert all(run_scalar(between, col) == unit(j) for j, col in enumerate(backward)) + assert forward[0][0] == backward[0][0] == 0 + columns = [[u + forward[j][0] * v for u, v in zip([Q(i == j == 0) for i in range(4)], backward[0], strict=True)] + for j in range(4)] + assert list(map(list, zip(*columns, strict=True))) == [[Q(x) for x in row] for row in previous['projector']] + assert sum(columns[i][i] for i in range(4)) == 2 + return [[str(x) for x in row] for row in zip(*columns, strict=True)] + + +def pop_parity(x): + return x.bit_count() & 1 + + +def quadratic(x): + w = x.bit_count() + return ((w * (w-1)) // 2) & 1 + + +def polar(x, y): + return pop_parity(x & y) ^ (pop_parity(x) & pop_parity(y)) + + +def rank2(rows): + pivots = {} + for r in rows: + while r: + p = r.bit_length()-1 + if p not in pivots: + pivots[p] = r + break + r ^= pivots[p] + return len(pivots) + + +def form_rows(basis): + return [sum(polar(x, y) << j for j, y in enumerate(basis)) for x in basis] + + +def stop(*_): + raise TimeoutError('R215 independent 20-second cap') + + +def main(): + assert __debug__ and implementation.name == 'cpython' and version_info[:2] == (3, 12) + assert len(argv) == 2, 'pass exact #7416 research package root' + root = Path(argv[1]).resolve() + signal(SIGALRM, stop) + alarm(CAP) + source = {p: pin(root, p) for p in PINS} + manifest = source['inputs/7113-SHA256.json'] + assert manifest['expected/ODD-TYPE-AB-CALLER.json'] == PINS['inputs/CALLER.json'] + assert manifest['expected/ODD-PHYSICAL-BINDING.json'] == PINS['inputs/PHYSICAL-BINDING.json'] + assert manifest['replay/supplier7112/short-caller/signed_child.py'] == PINS['inputs/7113-signed-child.py'] + previous, quote = [source['receipts/'+engine+'.json'] for engine in ('INDEPENDENT','LEAD')] + for p in (previous, quote): + assert (p['head'], p['caller'], tuple(p['clocks'])) == (HEAD, CALLER, CLOCKS) + assert previous['selected_axes'] == list(range(137, 145)) and quote['selected_bits'] == 8 + binding = source['inputs/PHYSICAL-BINDING.json'] + assert binding['caller_sha256'] == PINS['inputs/CALLER.json'] and binding['occurrence_and_geometry']['ambient'] == 145 + projector = stage(source['inputs/CALLER.json'], previous) + c = next(literal_eval(n.value) for n in parse(source['inputs/7113-signed-child.py']).body + if isinstance(n, Assign) and isinstance(n.targets[0], Name) and n.targets[0].id == 'C') + for sign, twice_eigen in ((1, (2, 0)), (-1, (0, 2))): + for i in (0, 1): + assert tuple(c[i][0][k]+sign*c[i][1][k] for k in (0, 1)) == tuple(sign**i*t for t in twice_eigen) + affordability = Q(quote['rank16_affordability'][1]) + assert affordability == Q(previous['affordability_upper']) < Q('1.003') + n = 1 << M + standard = [1 << j for j in range(M)] + assert all(polar(x, y) == quadratic(x ^ y) ^ quadratic(x) ^ quadratic(y) for x in standard for y in standard) + assert rank2(form_rows(standard)) == M + masks = [n-1, *[3 << (2*j) for j in range(4)]] + kernel = [*masks[1:], *[(1 << 8) | (1 << i) for i in range(9, 16)]] + assert rank2(masks) == 5 and rank2(kernel) == 11 + assert all(not pop_parity(m & v) for m in masks for v in kernel) + assert rank2(form_rows(kernel)) == 6 + cases = [[0]*4 for _ in range(32)] + for x in range(n): + k = sum(pop_parity(x & mask) << j for j, mask in enumerate(masks)) + residue = x.bit_count() % 4 + assert residue == pop_parity(x) + 2*quadratic(x) + cases[k][residue] += 1 + assert all(sum(row) == 1 << 11 for row in cases) + peak = max(max(row) for row in cases) + assert Q(peak,1<<11) == Q(9,16) + max_bias = max(abs(Q(row[0]+row[1]-row[2]-row[3], 1<<11)) for row in cases) + assert max_bias == Q(1,8) + extremal = [k for k,row in enumerate(cases) if max(row) == peak] + exact_control_min_displacement = 2*(n-sum(map(max,cases))) + core = [1,0,0,0] + for _ in range(16*F): + core = [core[i]+core[(i-1)%4] for i in range(4)] + core_fixed = Q(core[0], 1 << (16*F)) + assert core_fixed == Q(1,4)+Q(1,1<<17) + required = Q(7,8)*n + core_capacity = Q(3,4) + volume_lower = required / (n*core_capacity) + assert volume_lower == Q(7,6) > affordability + alarm(0) + print(dumps({'head':HEAD,'caller':CALLER,'pr7416':PREDECESSOR,'pins':PINS,'clocks':CLOCKS, + 'local_projector':projector,'f':F,'bits':M,'addresses':n,'sketch_probes':masks, + 'restricted_polar_rank':6,'coset_phase_counts':cases,'max_phase_fraction':'9/16', + 'max_quadratic_bias':str(max_bias),'extremal_cosets':extremal, + 'exact_control_min_displacement':exact_control_min_displacement, + 'universal_required_displacement':str(required),'core_phase_counts':core, + 'core_fixed_fraction':str(core_fixed),'core_capacity_fraction_upper':str(core_capacity), + 'required_volume_lower':str(volume_lower),'affordability_upper':str(affordability), + 'runner_cap_seconds':CAP},sort_keys=True,indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-stage17-parity-sketch-erasure-bound/engines/lead.py b/research/p104-stage17-parity-sketch-erasure-bound/engines/lead.py new file mode 100644 index 0000000000..d03662c6d5 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/engines/lead.py @@ -0,0 +1,77 @@ +"""Five-parity erased-map rank bound on the exact two stage-17 lanes.""" +from collections import Counter +from fractions import Fraction as F +from hashlib import sha256 +from json import dumps,loads +from math import comb +from pathlib import Path +from runpy import run_path +from signal import alarm + +ROOT = Path(__file__).resolve().parents[2] +PINS = { + 'lead/inputs/CALLER.json':'255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', + 'round214/lead/inputs/PROJECTOR.json':'c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35', + 'round214/lead/inputs/pricing.py':'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', +} + + +def rank2(rows): + basis = {} + for row in rows: + while row: + pivot = row.bit_length()-1 + if pivot not in basis: + basis[pivot] = row + break + row ^= basis[pivot] + return len(basis) + + +def main(): + assert __debug__ + alarm(20) + for name,digest in PINS.items(): + assert sha256((ROOT/name).read_bytes()).hexdigest() == digest + caller = loads((ROOT/'lead/inputs/CALLER.json').read_bytes()) + assert caller['events'][4646] == caller['events'][4660] == ['B','IDLE_ONE',36,[17]] + assert len(caller['types']['B']['ports']) == 8 + proj = loads((ROOT/'round214/lead/inputs/PROJECTOR.json').read_bytes()) + assert proj['rank'] == 2 and proj['inclusive_window'] == [4646,4660] + m,k = 16,5 + mask = (1<= F(1,4) + capacity_per_volume = F(3,4) + min_volume = required/capacity_per_volume + h = run_path(str(ROOT/'round214/lead/inputs/pricing.py'))['power_bounds'] + lo,hi = map(F,('0.00364665195644044790699554028334161','0.00364665195644044790699554028334162')) + funded_volume_upper = 2*h(8,lo)[1]/h(16,hi)[0] + gross_upper = 16*h(8,lo)[1]-8*min_volume*h(16,hi)[0] + assert min_volume == F(7,6) > F(1003,1000) > funded_volume_upper and gross_upper < 0 + alarm(0) + print(dumps({'pins':PINS,'width':2,'clocks':[4646,4660],'parity_cap':k,'polar_rank':m, + 'restricted_rank_lower':least_restriction_rank,'residue_fraction_upper':str(max_residue), + 'control_probes':probes,'control_max_fraction':str(empirical), + 'target_displacement_per_old_lane_lower':str(required),'normalized_core_fixed_fraction':str(fixed_fraction), + 'core_capacity_per_volume_upper':str(capacity_per_volume),'required_volume_lower':str(min_volume), + 'funded_volume_upper':str(funded_volume_upper),'gross_upper':str(gross_upper), + 'control_cap':1,'runner_cap_seconds':20},sort_keys=True,indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-SHA256.json b/research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-SHA256.json @@ -0,0 +1,69 @@ +{ + "replay/supplier7108/CALLER.json": "9557f713ab4ffb91ede05e8a6d5668c694b9940fc16f2f2d657e2f2b2cac2d3f", + "replay/supplier7112/RESULT.json": "7b808ff32d9803084aaaf820cd172ddc9001c7aebbd17e0324e779abeff91b30", + "replay/supplier7112/WORD.json.gz": "fe0b1dc3049a6b72760a705af2e698e0e9998e969e19862a696eba63434eb233", + "replay/supplier7112/short-caller/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "replay/supplier7112/short-caller/ODD-LOCALIZED-GROUPING.json": "8aac6b3d9e528bffbcf411bbd300c8e0f0b7bf75da45ab12badf3f3530ffcbe2", + "replay/supplier7112/short-caller/ODD-UNIT-DYADIC-TAPES.json": "c3195057f7a6723a81172ed540d0f1c4ba699ff3cb8dc37cbde7bb481d9b976c", + "replay/supplier7112/short-caller/ODD-UNIT-PREFIX-CLOSURES.json": "3b953e5d3e83e7573a3e908a5a23edb78773d4d22816aca54f766f0f0e9f5403", + "replay/supplier7112/short-caller/SHORT-ADMISSION-PARTIAL.json": "7977815fe72382738727e3d550eea3bc735923c9c57968872d4f863cb39cd401", + "replay/supplier7112/short-caller/SHORT-CALLER-RAW-PRICE.json": "a4f83d65d250efb40f6506658374d7414afdde11c96eb88b7d2fbb182aa090c1", + "replay/supplier7112/short-caller/SHORT-CATALOGUE-0-1000.log": "a916a76627fb79bf606b22f857ca93db6342891fb2c85b20658b5002c359e422", + "replay/supplier7112/short-caller/SHORT-CATALOGUE-1000-2000.log": "da633bfa408e98a2f2a958262a09d5e4274a9b25f7b4a6a73df5a97f37338f79", + "replay/supplier7112/short-caller/SHORT-CATALOGUE-2000-3047.log": "e8d500c0261a4a9e0cf3da2838d82806ed497ab9cf57cb8620ca6debfb98525c", + "replay/supplier7112/short-caller/SHORT-PRECISION.json": "68a00d2b83ee2eb944d2e05fc7f32bc9aa37282c45b968f0ab6fd500659ac028", + "replay/supplier7112/short-caller/SHORT-TYPE-A-ROOT.json": "e9812d720942d8149c219dfa28c1081ff1d353529e5282ca4624a04233f38f88", + "replay/supplier7112/short-caller/admission-source/ARCHIVE-CHAIN.json": "6de95c4eb396e69883fbeeb3989782bbbe232c22644af1c804050badca10f456", + "replay/supplier7112/short-caller/admission-source/FULL-RESULT.json": "d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7", + "replay/supplier7112/short-caller/admission-source/INDEPENDENT-NOTICE.md": "cadbc642ca84311d2c7a6cf704c7828cb4cf77e3c784b66e4c6e8a5c28002fb8", + "replay/supplier7112/short-caller/admission-source/INDEPENDENT-SOURCES.json": "dced1457df5230466ba6202fd6d4595bc2b7fb2a65302806bf2720b1837ff350", + "replay/supplier7112/short-caller/admission-source/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "replay/supplier7112/short-caller/admission-source/NATIVE-INPUTS.json": "9bb6c1567783661334d6c1d23f715ce5635cbbb513678819ab9e020a34c7e4c0", + "replay/supplier7112/short-caller/admission-source/NOTICE": "da12736e2e824167ff56f2ecb623a5f88f75a270410360890f61dffc33bab249", + "replay/supplier7112/short-caller/admission-source/data/bit-admission.json": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b", + "replay/supplier7112/short-caller/admission-source/data/caller.json": "3828d53e80ea97e8b866320f081af20b6b93bfebd58b95b56b85a7afe151af5e", + "replay/supplier7112/short-caller/admission-source/data/final.json.gz": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "replay/supplier7112/short-caller/admission-source/frozen/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "replay/supplier7112/short-caller/admission-source/frozen/native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "replay/supplier7112/short-caller/admission-source/frozen/physical.py": "4e995d1158033d83bf69b671f23dc7924d66edbbe07623ba063ba7421234ea20", + "replay/supplier7112/short-caller/admission-source/frozen/verify_host3_odd.py": "e75ad2096ba2587d1dc9c8982b2c2eb7c6fd2636a80adcd943314ef2cf6fd258", + "replay/supplier7112/short-caller/admission-source/independent.py": "21f46a8340331abb1486b50bd4e04453f1968b0a5950d86ff7780dd368590874", + "replay/supplier7112/short-caller/admission-source/interval_gate.py": "60a743d13f668ef86db4b8215b4d5d04430a671ba6f1fe06d9c1c4c3dfe86da5", + "replay/supplier7112/short-caller/admission-source/precision_replay.py": "850d9098c5946ab27ef5228acc54d59df2196e72259d3e21588ec0c319c8f5ee", + "replay/supplier7112/short-caller/admission-source/retained/odd-native-common-grid/independent_bounds.py": "198521def614fe78fa728f1dde2b7fb820c0c0e0ac3ad0c9224dccbf51eac0d5", + "replay/supplier7112/short-caller/admission-source/retained/query-only-precision-envelope/envelopes.py": "783da6b5b450fc07434946cb9ec86070dfee01df6b5fa1c385cb024def2c9a9f", + "replay/supplier7112/short-caller/admission-source/retained/query-only-precision-envelope/source_binding.py": "624c459311c58f3847b7713b818bfd340153abf42919f02ac9aa8892ed52a2bd", + "replay/supplier7112/short-caller/assemble_odd_application.py": "6cdac39ab196a70c53ba2283c2555cd8dee30644dcc4769628b46fb53bd55a1f", + "replay/supplier7112/short-caller/candidate_gate.py": "e71097ca81a082afd7c647324a6c94cb357aeb1084693a095a0f3e0b45a9b11a", + "replay/supplier7112/short-caller/check_odd_caller_exact_grid.py": "abd5a5fd011b71e5b382cbc058855594d4f2fe7b049f375506675c0303180f54", + "replay/supplier7112/short-caller/check_odd_fixed_tape_counts.py": "e6246e9f8fbeae3077d82e585eafd3647c1a8758c58f33c7c13e7efa6c1e42bb", + "replay/supplier7112/short-caller/check_odd_partial_admission.py": "4416b1ea5f07f8a91028a2e500116588fbdfaed95a8ef9bac7a46bcb44b9478e", + "replay/supplier7112/short-caller/check_odd_physical_binding.py": "5c80c3b0415a7f91d216395248dd6f13297eed637732098e1ca8fb0548951b98", + "replay/supplier7112/short-caller/check_odd_precision.py": "b2d9c13577158157a587ace766d9dadb7819a0164b372722329d9754e1be6c61", + "replay/supplier7112/short-caller/connected.py": "469537b46fb92c5aca926d3b1497da5425408673b0a73ba1427f23d872b414e7", + "replay/supplier7112/short-caller/cut_library.py": "7ccb81af19db54ec7cdb44849af018d4ca8893f80f17277914f8566715985133", + "replay/supplier7112/short-caller/emit_odd_type_ab.py": "7a7993648433c6febad8c07b315aec1b96598835a3f587b62040423c33c3b71f", + "replay/supplier7112/short-caller/emit_odd_type_b.py": "d1fa8b67d98beacd6bb574b3d5fcbc94b8646a7ffbce91d2a6fd4d690d3c5329", + "replay/supplier7112/short-caller/host34.py": "bded1a8626d65ee40c4ba3b25780fc03f0fa08906f3c83f631892df072d9a9b7", + "replay/supplier7112/short-caller/independent.py": "21f46a8340331abb1486b50bd4e04453f1968b0a5950d86ff7780dd368590874", + "replay/supplier7112/short-caller/interval_gate.py": "60a743d13f668ef86db4b8215b4d5d04430a671ba6f1fe06d9c1c4c3dfe86da5", + "replay/supplier7112/short-caller/lower.py": "67345fdfc8e5bb816e24b37dfafad0396372c48ec4e1b95b8b69f019a8fdfdee", + "replay/supplier7112/short-caller/mirrored.py": "55dd441a3a7f504b351857d45fd701994a0950ae1baec6c4c2b4b0166fb69db3", + "replay/supplier7112/short-caller/odd_unit_dyadic_tapes.py": "3cdafa35635360a487ce400ec8d585f6134dd7c58209543528e98e7db178bbc7", + "replay/supplier7112/short-caller/screen.py": "01e3eaba4b710a080e6e393e53157e6a119fdf312620eed26e9185ca91f6bea6", + "replay/supplier7112/short-caller/short_dyadic_seam.py": "6e588b365618ab2df4fa2d1f16073d09a953a7cd6e826e1f96bbf87f950b672b", + "replay/supplier7112/short-caller/short_native_catalogue.py": "775695c379f407801910531565cc371012cee501b2cec5f5d718ecdccf06b64d", + "replay/supplier7112/short-caller/signed_child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "replay/supplier7112/short-caller/signed_model.py": "f88c798b9a22c656ea0b755b4f32be411c1f80687dff1a1ac9e9c2a0b5f4203e", + "replay/supplier7112/short-caller/stage.py": "0ab5546e926dd98d3ad833909b534840b7d8d0467c4790ca09bc2b14b37313f5", + "replay/supplier7112/short-caller/upstream_application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "replay/supplier7112/short-caller/upstream_native_catalogue.py": "6120e1ea1e07eeba757694d209437a38f121b0a377cc466889a30fa52c561472", + "expected/ODD-8X9-APPLICATION-CHECKS.json": "10512d62f540fe7bb839ec94b6a21bbdf4a3dfadf56b4ec9095d4b242bda19b8", + "expected/ODD-ADMISSION-PARTIAL.json": "75ec76e4393ef1622fcff9e2727dc411921076af4a506d97506665add140fa86", + "expected/ODD-CALLER-EXACT-GRID.json": "87d25d9fa3778bf4784e3a9e17f32ce5ba372663c6e97392cc62b87e6719042c", + "expected/ODD-FIXED-TAPE-COUNTS.json": "1a8bf36a966edca8c61f3be803cdbe136307095dec40245cdc93e79a9062fe99", + "expected/ODD-PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "expected/ODD-PRECISION.json": "9c03607288cc2afb80cb02c197f93360978233036418b32b09ad91be16f9c153", + "expected/ODD-TYPE-AB-CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "expected/ODD-TYPE-AB-REPLAY.json": "71fd0a7ad8b743266c6a75100f3543b48ea7d6fcbe45f008d3b61270e3b660a0" +} diff --git a/research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-signed-child.py b/research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-signed-child.py new file mode 100644 index 0000000000..0980a6559b --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/inputs/7113-signed-child.py @@ -0,0 +1,146 @@ +"""Exact nine-slot signed child on the retained 153-coordinate field layout.""" + +from collections import Counter +from hashlib import sha256 +from pathlib import Path +from random import Random +import argparse +import json + +LAYOUT = 153 +EXPECTED_PORTS = (15, 17, 27, 34, 35, 42, 47, 55) +NOTE_SHA = '64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c' +# Integer numerators over 2 in the exact C gate. +C = (((1, 1), (1, -1)), ((1, -1), (1, 1))) +PHASE = ((1, 0), (0, -1), (-1, 0), (0, 1)) + + +def multiply(x, y): + a, b = x + c, d = y + return a*c - b*d, a*d + b*c + + +def conjugate(z): + a, b = z + return a, -b + + +def matrix_product(a, b): + return tuple(tuple(tuple(sum(multiply(a[i][k], b[k][j])[c] for k in range(2)) + for c in range(2)) for j in range(2)) for i in range(2)) + + +def swap_blocks(label, a, b, width): + mask = (1 << width)-1 + delta = ((label >> (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-sketch-erasure-bound/receipts/LEAD.json b/research/p104-stage17-parity-sketch-erasure-bound/receipts/LEAD.json new file mode 100644 index 0000000000..127ccbafa9 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-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-sketch-erasure-bound/receipts/R215-INDEPENDENT.json b/research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-INDEPENDENT.json new file mode 100644 index 0000000000..483e729e94 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-INDEPENDENT.json @@ -0,0 +1,267 @@ +{ + "addresses": 65536, + "affordability_upper": "158791308614353583156174418249367563719088592914764/158390443979059730051412021176512143650724409161655", + "bits": 16, + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "clocks": [ + 4646, + 4660 + ], + "core_capacity_fraction_upper": "3/4", + "core_fixed_fraction": "32769/131072", + "core_phase_counts": [ + 1073774592, + 1073741824, + 1073709056, + 1073741824 + ], + "coset_phase_counts": [ + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1024, + 0, + 1024, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ], + [ + 1152, + 0, + 896, + 0 + ], + [ + 0, + 1024, + 0, + 1024 + ] + ], + "exact_control_min_displacement": 65280, + "extremal_cosets": [ + 30 + ], + "f": 2, + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "local_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" + ] + ], + "max_phase_fraction": "9/16", + "max_quadratic_bias": "1/8", + "pins": { + "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", + "receipts/INDEPENDENT.json": "435620f25a7f15c2d67a0a511e6d7d699b0cfb307a0fd053c09d84dbe8ac1bbb", + "receipts/LEAD.json": "95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26" + }, + "pr7416": "8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9", + "required_volume_lower": "7/6", + "restricted_polar_rank": 6, + "runner_cap_seconds": 20, + "sketch_probes": [ + 65535, + 3, + 12, + 48, + 192 + ], + "universal_required_displacement": "57344" +} diff --git a/research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-LEAD.json b/research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-LEAD.json new file mode 100644 index 0000000000..a0ca96b42c --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/receipts/R215-LEAD.json @@ -0,0 +1,32 @@ +{ + "clocks": [ + 4646, + 4660 + ], + "control_cap": 1, + "control_max_fraction": "9/16", + "control_probes": [ + 65535, + 3, + 12, + 48, + 192 + ], + "core_capacity_per_volume_upper": "3/4", + "funded_volume_upper": "158791308614353583156174418249367567021061028818664/158390443979059730051412021176512143650724409161655", + "gross_upper": "-155985256167296611422837638739379603428704691219601/7500000000000000000000000000000000000000000000000", + "normalized_core_fixed_fraction": "32769/131072", + "parity_cap": 5, + "pins": { + "lead/inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "round214/lead/inputs/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "round214/lead/inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182" + }, + "polar_rank": 16, + "required_volume_lower": "7/6", + "residue_fraction_upper": "9/16", + "restricted_rank_lower": 6, + "runner_cap_seconds": 20, + "target_displacement_per_old_lane_lower": "7/8", + "width": 2 +} diff --git a/research/p104-stage17-parity-sketch-erasure-bound/replay.py b/research/p104-stage17-parity-sketch-erasure-bound/replay.py new file mode 100644 index 0000000000..dfd13fe9c2 --- /dev/null +++ b/research/p104-stage17-parity-sketch-erasure-bound/replay.py @@ -0,0 +1,102 @@ +"""Authenticate and replay the exact stage-17 five-parity capacity bound.""" +from fractions import Fraction as Q +from hashlib import sha1, sha256 +from json import dumps, loads +from pathlib import Path +from subprocess import run +from sys import executable, implementation, stderr, version_info +from tempfile import TemporaryDirectory + +ROOT = Path(__file__).resolve().parent + + +def unique(items): + out = dict(items) + if len(items) != len(out): + raise ValueError('duplicate JSON key') + return out + + +def data(name): + file = (ROOT / name).resolve() + assert file.is_relative_to(ROOT) and file.relative_to(ROOT).as_posix() == name + return file.read_bytes() + + +def read(name): + return loads(data(name), object_pairs_hook=unique) + + +def authenticate(): + for name, digest in read('LOCAL-PINS.json').items(): + raw = data(name) + assert sha256(raw).hexdigest() == digest, name + if name.endswith('.json'): + loads(raw, object_pairs_hook=unique) + for name, prov in read('PROVENANCE.json')['files'].items(): + raw = data(name) + assert sha256(raw).hexdigest() == prov['sha256'] + assert sha1(f'blob {len(raw)}\0'.encode() + raw).hexdigest() == prov['git_blob'] + + +def copy(name, target): + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data(name)) + + +def execute(path, arguments, receipt=None): + result = run([executable, '-I', '-B', str(path), *map(str, arguments)], capture_output=True, timeout=22) + if receipt is None: + assert result.returncode == 1 and b'AssertionError' in result.stderr and not result.stdout + return None + if result.returncode: + stderr.write(result.stderr.decode(errors='replace')) + result.check_returncode() + assert result.stdout == data(receipt), receipt + return loads(result.stdout, object_pairs_hook=unique) + + +def compare(a, b): + assert a['clocks'] == b['clocks'] == [4646, 4660] + assert a['width'] == b['f'] == 2 and a['parity_cap'] == 5 + assert a['polar_rank'] == b['bits'] == 16 + assert a['restricted_rank_lower'] == b['restricted_polar_rank'] == 6 + assert a['control_probes'] == b['sketch_probes'] + assert a['control_max_fraction'] == b['max_phase_fraction'] == '9/16' + assert b['extremal_cosets'] == [30] and b['exact_control_min_displacement'] == 65280 + assert b['universal_required_displacement'] == '57344' + assert a['normalized_core_fixed_fraction'] == b['core_fixed_fraction'] == '32769/131072' + assert a['core_capacity_per_volume_upper'] == b['core_capacity_fraction_upper'] == '3/4' + assert a['required_volume_lower'] == b['required_volume_lower'] == '7/6' + assert Q(b['affordability_upper']) <= Q(a['funded_volume_upper']) < Q('1.003') + assert Q(a['gross_upper']) < Q('-20.798') + + +def main(): + assert __debug__ and implementation.name == 'cpython' and version_info[:2] == (3, 12) + authenticate() + with TemporaryDirectory(prefix='p104-parity-sketch-') as directory: + temp = Path(directory) + lead = temp / 'round215/lead/parity_sketch.py' + for source, dest in ( + ('engines/lead.py', lead), + ('inputs/CALLER.json', temp / 'lead/inputs/CALLER.json'), + ('inputs/PROJECTOR.json', temp / 'round214/lead/inputs/PROJECTOR.json'), + ('inputs/pricing.py', temp / 'round214/lead/inputs/pricing.py'), + ): + copy(source, dest) + a = execute(lead, [], 'receipts/R215-LEAD.json') + independent = ROOT / 'engines/independent.py' + b = execute(independent, [ROOT], 'receipts/R215-INDEPENDENT.json') + compare(a, b) + for name in b['pins']: + copy(name, temp / 'mutant' / name) + wrong = read('inputs/CALLER.json') + wrong['events'][4646][3] = [16] + (temp / 'mutant/inputs/CALLER.json').write_text(dumps(wrong)) + execute(independent, [temp / 'mutant']) + print('PASS_P104_STAGE17_PARITY_SKETCH_ERASURE_BOUND') + + +if __name__ == '__main__': + main()