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 a5fa7b464a773afb47eb8b9725b94f660c407528 Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Thu, 12 Nov 2026 03:16:40 -0800 Subject: [PATCH 3/3] Bound one-field packing for the stage-17 Type B returns --- .../LOCAL-PINS.json | 17 + .../NOTICE | 2 + .../PROOF.md | 69 + .../PROVENANCE.json | 77 + .../README.md | 58 + .../SOURCES.json | 18 + .../TASK.json | 117 + .../VERIFICATION.md | 19 + .../VERIFY.json | 14 + .../engines/count_modes.py | 90 + .../engines/tensor_columns.py | 192 ++ .../inputs/7113-SHA256.json | 69 + .../inputs/7113-application.py | 369 +++ .../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/R92-PRICE.json | 2539 +++++++++++++++++ .../inputs/pricing.py | 82 + .../receipts/R173-INDEPENDENT.json | 88 + .../receipts/R173-LEAD.json | 39 + .../replay.py | 125 + 24 files changed, 4420 insertions(+) create mode 100644 research/p104-stage17-two-return-volume-bound/LOCAL-PINS.json create mode 100644 research/p104-stage17-two-return-volume-bound/NOTICE create mode 100644 research/p104-stage17-two-return-volume-bound/PROOF.md create mode 100644 research/p104-stage17-two-return-volume-bound/PROVENANCE.json create mode 100644 research/p104-stage17-two-return-volume-bound/README.md create mode 100644 research/p104-stage17-two-return-volume-bound/SOURCES.json create mode 100644 research/p104-stage17-two-return-volume-bound/TASK.json create mode 100644 research/p104-stage17-two-return-volume-bound/VERIFICATION.md create mode 100644 research/p104-stage17-two-return-volume-bound/VERIFY.json create mode 100644 research/p104-stage17-two-return-volume-bound/engines/count_modes.py create mode 100644 research/p104-stage17-two-return-volume-bound/engines/tensor_columns.py create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/7113-SHA256.json create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/7113-application.py create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/7113-signed-child.py create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/7397-PROOF.md create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/CALLER.json create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/PHYSICAL-BINDING.json create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/PR7362-SHA256.json create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/PROJECTOR.json create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/R92-PRICE.json create mode 100644 research/p104-stage17-two-return-volume-bound/inputs/pricing.py create mode 100644 research/p104-stage17-two-return-volume-bound/receipts/R173-INDEPENDENT.json create mode 100644 research/p104-stage17-two-return-volume-bound/receipts/R173-LEAD.json create mode 100644 research/p104-stage17-two-return-volume-bound/replay.py diff --git a/research/p104-stage17-two-return-volume-bound/LOCAL-PINS.json b/research/p104-stage17-two-return-volume-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..a78653e442 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/LOCAL-PINS.json @@ -0,0 +1,17 @@ +{ + "PROVENANCE.json": "da91e6adea52c71983f4ddf3dd10a1a5a591e8a00f9d970e76e2f185b5686c2d", + "engines/count_modes.py": "3c53d3041a5f11a96f1c9c41eaafee820612722bed485fc4b69d1f050cf059e5", + "engines/tensor_columns.py": "0f6ba90966829032c0f5e459b3141c7a85ac016143c72b992eb2908322a426e6", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "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/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/R173-INDEPENDENT.json": "d53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32", + "receipts/R173-LEAD.json": "038e7fbac567d0e638951ab7fc1650a3a6d6ab0f01acb037d6854341e25a9a46" +} diff --git a/research/p104-stage17-two-return-volume-bound/NOTICE b/research/p104-stage17-two-return-volume-bound/NOTICE new file mode 100644 index 0000000000..36e4c1cea8 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/NOTICE @@ -0,0 +1,2 @@ +Apache-2.0 contribution. See README.md and PROVENANCE.json for exact source attribution. +OpenAI Codex and subagents materially assisted the proof, independent implementation and verification. diff --git a/research/p104-stage17-two-return-volume-bound/PROOF.md b/research/p104-stage17-two-return-volume-bound/PROOF.md new file mode 100644 index 0000000000..1f985e6ea0 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/PROOF.md @@ -0,0 +1,69 @@ +# Exact local action and volume + +The retained 4,783-event caller places Type B IDLE_ONE on global role 36 +with mask {17} at zero-based clocks 4646 and 4660. The eight Type B ports +are 15, 17, 27, 34, 35, 42, 47 and 55. The 13 interior events are rational +ADD and nonzero SCALE on roles 36, 37, 52 and 53. They are independent +of both the central phase and stage-17 body. + +Let $M$ be their exact scalar product, let $E$ project onto role 36 +and let $x=D_{17}-I$ act on the address coordinates. The old physical +map on the window is $(I+E\otimes x)(M\otimes I)(I+E\otimes x)$. +Normalize by multiplying on the left by $M^{-1}\otimes I$. With +$F=M^{-1}EM$, the remaining product is $(I+F\otimes x)(I+E\otimes x)$. +The exact matrix product gives $M_{00}=(M^{-1})_{00}=0$. +Consequently $EF=FE=0$, so the normalized required map is +$I+(E+F)\otimes(D_{17}-I)$. The idempotent $P=E+F$ has trace and +rank two. This identity retains the two arbitrary dirty input directions. + +The #7113 physical binding allocates eight disjoint stage axes to +each even IDLE_ONE, here zero-based axes 137 through 144. Its literal +binary gate is the symmetric matrix $C$ with diagonal $(1+i)/2$ and +off-diagonal $(1-i)/2$. The Walsh vectors $(1,1)$ and $(1,-1)$ have +eigenvalues 1 and $i$. At column multiplicity $f$, $D_{17}$ acts as +$C^{\otimes 8f}$ on the active axes and identity on all spectators. +At width one with one spectator bit the exact modes per lane are 144, +128, 112 and 128 for $1,i,-1,-i$. There are 368 displaced directions +in each 512-column lane and 736 across the two independent lanes. + +For every integer $f\ge1$, the identity class fraction is +$1/4+2^{-4f-1}$. The roots-of-unity filter on the binomial weights gives +$2^{8f-2}+2^{4f-1}$ identity modes among $2^{8f}$, and spectator factors +cancel in the fraction. Thus the required displacement has rank +$2(3/4-2^{-4f-1})V\ge(23/16)V$ for lane dimension $V$, using rank +multiplicativity for $P\otimes(D_{17}-I)$. +This uses the actual body against the fixed erased ordinary window. + +## Necessary price + +Specify one body-dependent core $K$ on one field of dimension $V'$, with +body-independent linear maps $A,B$ and bypass unchanged on erasure. After +normalizing the old window, setting $K=I$ must give the identity. +The added action is $B(K-I)A$ and has rank at most $V'$, including +if the maps mix dirty lanes or spectator coordinates. Restoration and +ownership requirements can only narrow this class. Therefore +$V'/V\ge23/16$. The capacity bound is valid without a specific +core spectrum. + +At the same per-coordinate representation, the conditional tariff +in #7397 charges $8(V'/V)H_{16}$ across the eight ports against +removed charge $16H_8$, with $H_r=r^{1-\kappa}$. The affordability +ratio is $2H_8/H_{16}=2^\kappa$. The exact directed interval at +the old crossing bounds it above by 1.003 and gives the stated raw +delta upper before any ancillary charges. The exclusion extends +throughout the retained BIT ceiling since $\kappa\le0.00376669<1/2$ +and $2^{1/2}<23/16$, the latter by squaring. Higher charged ranks +can only increase the price for the same field volume in this range. +The other paid and productive jobs are fixed. + +For the additional canonical same-width rank-16 tensor model with a +fourth-root global phase and any signed independent axes, the maximum +core displacement fraction is at most $3/4+2^{-8f-1}$. The smallest +eigenphase class has fraction $1/4-2^{-8f-1}$. Sign reversal and +fourth-root phase only permute the classes. The resulting necessary +ratio is at least $736/385$ for $f\ge1$ and its lower bound tends to +two with $f$. The rank-16 price gate uses the weaker arbitrary-core bound. + +A changed erased action, another body-dependent bypass, or a shared +provider with a different charged output dimension or tariff lies +outside these hypotheses. No edited caller or provider is claimed. diff --git a/research/p104-stage17-two-return-volume-bound/PROVENANCE.json b/research/p104-stage17-two-return-volume-bound/PROVENANCE.json new file mode 100644 index 0000000000..8d0dfe4935 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/PROVENANCE.json @@ -0,0 +1,77 @@ +{ + "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/PROJECTOR.json": { + "role": "Frozen R172 lead local normalized projector receipt. The tensor-column engine reconstructs the physical local projection directly from the caller.", + "source": "https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19562744" + }, + "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-application.py": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "1a6d358cbec88e70615e5314cdfca9e123124f83", + "path": "research/signed-caller-8x9/replay/supplier7112/short-caller/upstream_application.py", + "sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/replay/supplier7112/short-caller/upstream_application.py" + }, + "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/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" + } + }, + "schema_version": 1 +} diff --git a/research/p104-stage17-two-return-volume-bound/README.md b/research/p104-stage17-two-return-volume-bound/README.md new file mode 100644 index 0000000000..c476b39287 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/README.md @@ -0,0 +1,58 @@ +# Bound one-field packing for the stage-17 Type B returns + +**NO VERIFIED GAIN.** The two exact Type B idles at clocks 4646 and 4660 of the +signed caller have complementary projectors. Their local action has an exact +rank-two formula. A single identity-erased core needs at least 23/16 times +the original lane volume to supply both full physical returns. A rank-16 +field can afford less than 1.003 times that volume under the conditional +volume-linear tariff. At the old crossing the eight-port raw price change +is below −55.11596368443582 with all ancillary costs granted free. + +The comparison is [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) +at `aaeec8c0acf01e99a5f331ef363a698d9c084ace` with signed +[#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) at +`07a76c5e2738882c0cb322278e56f6cae3c9885d`. The strongest reproduced +comparable exponent saving remains 0.00364665195644. + +The test uses the actual eight-axis stage-17 body and the fixed ordinary +erasure. It does not require a physical scalar −1 body response. See +[proof and scope](PROOF.md) for the all-width extension and unchanged-bypass +hypothesis. + +Run from a clean checkout with CPython 3.12 and assertions. + +```sh +python3.12 -I -B research/p104-stage17-two-return-volume-bound/replay.py +``` + +The self-contained replay authenticates the exact caller, signed child, +physical binding and directed tariff. Two engines independently obtain +the same mode multiplicities, displacement rank and price. The column +engine also reconstructs the literal four-role projector and applies the +Gaussian tensor in the full 512-column basis. Each engine is limited to 45 +seconds. See [verification](VERIFICATION.md) and [provenance](PROVENANCE.json). + +## Open next questions + +Can a distinct supplier realize both arbitrary-input returns with a +different erased map or a lower complete charge? Start with one specified +provider, two independent lanes and an exact definition of the erased +operation. Price any body-dependent bypass, ownership, routing and +restoration before checking the signed forward and adjoint action. +This result closes the unchanged identity-erased class at the proposed +rank and tariff. + +## Credit + +[#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) supplies the +complete benchmark. [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +supplies the signed caller and exact binary C gate. The preceding +[R172 checkpoint](https://github.com/CrocSwap/integer-mult-bounds/discussions/7111#discussioncomment-19562744) +records the complementary projector identity. [#7360](https://github.com/CrocSwap/integer-mult-bounds/pull/7360) +checks a single-projected replacement at the same clocks. +[#7315](https://github.com/CrocSwap/integer-mult-bounds/pull/7315) addresses +one-role fusion. [#7397](https://github.com/CrocSwap/integer-mult-bounds/pull/7397) +provides the conditional volume-linear tariff and the related odd-return +capacity method. [#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) +supplies the exact invoice receipt. OpenAI Codex and subagents materially +assisted the proof, implementation and independent replay. Apache-2.0. diff --git a/research/p104-stage17-two-return-volume-bound/SOURCES.json b/research/p104-stage17-two-return-volume-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-stage17-two-return-volume-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-two-return-volume-bound/TASK.json b/research/p104-stage17-two-return-volume-bound/TASK.json new file mode 100644 index 0000000000..311cdbea28 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "One exact #7334/#7113 Type B stage-17 even-idle pair at clocks 4646 and 4660, with fixed identity erasure, one field, and the volume-linear tariff.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 stage-17 two-return physical binding research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "The binding paid-body cost can fall only if one complete charged field delivers both independent full body returns.", + "budget_minutes": 12, + "evidence": "Exact local rank-two projector, two physical basis and capacity replays, and strictly negative complete optimistic price for the frozen replacement.", + "open_questions": [ + { + "blocked_by": "No changed provider or complete tariff proof has been supplied.", + "first_step": "Specify one provider and both arbitrary-input outputs, then charge its erased and body-dependent maps and verify the signed forward and adjoint action.", + "question": "Can a different erased map or supplier realize both stage-17 returns with favorable complete charge?", + "why_it_matters": "The fixed identity-erased one-field replacement loses the binding moment." + } + ], + "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": "Extend the two-return provider question to one even stage body using its literal physical tensor and fixed ordinary erasure.", + "scope_status": "changed", + "stop_rule": "Two responses, 512 basis columns per lane, and 45 runner seconds per replay. Stop when the lower field volume exceeds affordability.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-stage17-two-return-volume-bound/VERIFICATION.md b/research/p104-stage17-two-return-volume-bound/VERIFICATION.md new file mode 100644 index 0000000000..f039d89580 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/VERIFICATION.md @@ -0,0 +1,19 @@ +# Verification record + +At the sealed #7334 crossing, the lead mode-count replay validates the +literal binary eigenvectors and checks all 512 Walsh directions on one +spectator slice. It binds the exact #7113 physical-application receipt +and the prior R172 projector. The independent column replay derives +the local projector from the 15-event window and applies the physical +Gaussian tensor on every Walsh basis direction of a lane. Both lanes +have the same physical action, and their independent displacement ranks +add. Each runner has a 45-second cap and exited zero. The independent +run took 0.84 seconds on CPython 3.12.14. + +The package compares both regenerated receipts, checks exact agreement +on the prices and dimensions, verifies the uniform BIT-range inequality, +and rejects mutated caller bytes. Duplicate JSON keys and changed +package dependencies fail closed. The omitted-axis and duplicate-projector +controls distinguish errors that would undercount a required return. +An edited-word native, rounded or compiler replay was not applicable +because the scoped provider failed the price gate. diff --git a/research/p104-stage17-two-return-volume-bound/VERIFY.json b/research/p104-stage17-two-return-volume-bound/VERIFY.json new file mode 100644 index 0000000000..c42f090b0b --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Rebuild both physical displacement receipts, exact local projector and necessary directed price.", + "timeout_seconds": 100 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-stage17-two-return-volume-bound/engines/count_modes.py b/research/p104-stage17-two-return-volume-bound/engines/count_modes.py new file mode 100644 index 0000000000..f863a0b911 --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/engines/count_modes.py @@ -0,0 +1,90 @@ +"""Check the two-return displacement floor and complete one-pair price.""" +import ast +from fractions import Fraction +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 SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "inputs/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "inputs/signed_child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", +} + + +def stop(*_): + raise TimeoutError("45-second exact gate cap") + + +def tensor_classes(bits): + return [sum(comb(bits, i) for i in range(j, bits+1, 4)) for j in range(4)] + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(45) + raw = {p: (ROOT/p).read_bytes() for p in PINS} + for path, h in PINS.items(): + assert sha256(raw[path]).hexdigest() == h, path + c = loads(raw["inputs/CALLER.json"]) + b = loads(raw["inputs/PHYSICAL-BINDING.json"]) + p = loads(raw["inputs/PROJECTOR.json"]) + invoice = loads(raw["inputs/R92-PRICE.json"]) + assert b["caller_sha256"] == PINS["inputs/CALLER.json"] + assert b["occurrence_and_geometry"]["ambient"] == c["ambient_rank"] == 145 + assert c["stages"] == 17 and len(c["events"]) == 4783 + assert p["head"] == invoice["head"] and p["caller"] == invoice["caller_head"] + assert p["inclusive_window"] == [4646,4660] and p["rank"] == 2 + assert [c["events"][i] for i in p["inclusive_window"]] == [["B","IDLE_ONE",36,[17]]] * 2 + ports = c["types"]["B"]["ports"] + assert ports == [15,17,27,34,35,42,47,55] + assert list(range(9 + 8 * 16,145)) == list(range(137,145)) + + node, = [n for n in ast.parse(raw["inputs/signed_child.py"]).body if isinstance(n,ast.Assign) + and isinstance(n.targets[0],ast.Name) and n.targets[0].id == "C"] + gate = ast.literal_eval(node.value) + for sign, phase in ((1,(1,0)),(-1,(0,1))): + vector = (1,sign) + for row, v in zip(gate,vector,strict=True): + assert tuple(sum(row[j][i]*vector[j] for j in range(2)) for i in range(2)) == tuple(2*v*x for x in phase) + counts = tensor_classes(8) + assert counts == [72,64,56,64] + spectrum = [0] * 4 + for column in range(512): + # One frozen spectator bit. The low eight Walsh bits carry the body. + spectrum[(column & 255).bit_count() % 4] += 1 + assert spectrum == [2*n for n in counts] + rank = 512 - spectrum[0] + required = Fraction(2*rank,512) + assert rank == 368 and required == Fraction(23,16) + assert Fraction(rank,512) < required + assert sum(spectrum) == 512 + + tariff = run_path(str(ROOT/"inputs/pricing.py")) + k = Fraction(invoice["old_crossing_upper"]) + h8 = tariff["power_bounds"](8,k) + h16 = tariff["power_bounds"](16,k) + affordable = (2*h8[0]/h16[1],2*h8[1]/h16[0]) + assert affordable[1] < Fraction(1003,1000) < required + paid = tariff["cost"]({8:16,16:-8*required},k) + assert paid[1] < 0 + alarm(0) + print(dumps({"head":p["head"],"caller":p["caller"],"stage":17,"clocks":p["inclusive_window"], + "width1_walsh_multiplicities_one_spectator":spectrum,"width1_columns_per_lane":512, + "width1_rank_per_lane":rank,"width1_rank_both_lanes":2*rank, + "width1_erased_rank_both_lanes":0,"uniform_volume_lower":required, + "affordable_rank16_volume":affordable,"raw_gain_interval_upper_model":paid, + "scope":"physical D17 versus matching identity erasure, one body-dependent core, unchanged body-independent bypass", + "cases":2,"hard_cap_seconds":45,"pins":PINS},default=str,indent=2,sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-stage17-two-return-volume-bound/engines/tensor_columns.py b/research/p104-stage17-two-return-volume-bound/engines/tensor_columns.py new file mode 100644 index 0000000000..5cee14477e --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/engines/tensor_columns.py @@ -0,0 +1,192 @@ +"""Reconstruct a physical-body displacement and the necessary field volume.""" +import ast +import json +from fractions import Fraction as Q +from hashlib import sha256 +from math import comb +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +HERE = Path(__file__).resolve().parent +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/7113-application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "inputs/7397-PROOF.md": "1b5f670a1fd044b92905639b2cfb81eaf71c1dcdf63c114b73d2841919c58e32", +} +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +PORTS = [15, 17, 27, 34, 35, 42, 47, 55] +CLOCKS = [4646, 4660] +ROLES = [36, 37, 52, 53] +EIGENVALUE = [(1, 0), (0, 1), (-1, 0), (0, -1)] + + +def read(name): + content = (HERE / name).read_bytes() + if sha256(content).hexdigest() != PINS[name]: + raise ValueError(f"changed source {name}") + return content + + +def mm(a, b): + return [[sum(x*y for x, y in zip(row, col, strict=True)) for col in zip(*b)] for row in a] + + +def matadd(a, b): + return [[x+y for x, y in zip(r, s, strict=True)] for r, s in zip(a, b, strict=True)] + + +def product(a, b): + x, y = a + u, v = b + return x*u-y*v, x*v+y*u + + +def add(a, b): + return a[0]+b[0], a[1]+b[1] + + +def caller_projector(caller): + assert caller["types"]["B"]["ports"] == PORTS + tape = caller["events"] + assert len(tape) == 4783 + assert tape[CLOCKS[0]] == tape[CLOCKS[1]] == ["B", "IDLE_ONE", 36, [17]] + interior = tape[CLOCKS[0]+1:CLOCKS[1]] + assert len(interior) == 13 + ident = [[Q(i == j) for j in range(4)] for i in range(4)] + + def transform(events, invert): + a = [row[:] for row in ident] + for kind, op, dst, *args in events: + assert kind == "B" + j = ROLES.index(dst) + if op == "ADD": + k = ROLES.index(args[0]) + q = Q(args[1]) * (-1 if invert else 1) + a[j] = [x+q*y for x, y in zip(a[j], a[k], strict=True)] + else: + assert op == "SCALE" + q = Q(args[0]) + a[j] = [x/q if invert else x*q for x in a[j]] + return a + + m = transform(interior, False) + inv = transform(reversed(interior), True) + assert mm(inv, m) == mm(m, inv) == ident + e = [[Q(i == j == 0) for j in range(4)] for i in range(4)] + f = mm(mm(inv, e), m) + zero = [[Q(0) for _ in range(4)] for _ in range(4)] + assert mm(e, f) == mm(f, e) == zero + p = matadd(e, f) + assert mm(p, p) == p and sum(p[i][i] for i in range(4)) == 2 + assert mm(e, e) != zero + return p + + +def tensor_numerator(column, axes, gate): + out = column[:] + for axis in axes: + for j in range(len(out)): + if j & axis: + continue + k = j | axis + u, v = out[j], out[k] + out[j] = add(product(gate[0][0], u), product(gate[0][1], v)) + out[k] = add(product(gate[1][0], u), product(gate[1][1], v)) + return out + + +def physical_response(gate): + # The ninth bit is an unchanged spectator. All 512 columns form a + # Walsh basis on this literal C^8 tensor slice. + axes = tuple(1 << i for i in range(8)) + phases = [0]*4 + for c in range(512): + erased = [((-1)**((r & c).bit_count() & 1), 0) for r in range(512)] + actual = tensor_numerator(erased, axes, gate) + phase = (c & 255).bit_count() % 4 + phases[phase] += 1 + eigen = tuple(256*v for v in EIGENVALUE[phase]) + assert actual == [product(eigen, x) for x in erased] + assert phases == [144, 128, 112, 128] + # Negative control. Omit one paid axis on its Walsh minus direction. + omitted = [((-1)**((r & 128).bit_count() & 1), 0) for r in range(512)] + assert tensor_numerator(omitted, axes[:-1], gate) != [ + product((0, 128), x) for x in omitted + ] + return phases + + +def stop(*_): + raise TimeoutError("45-second response cap") + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(45) + body = ast.parse(read("inputs/7113-signed-child.py")) + gate, = [ast.literal_eval(node.value) for node in body.body + if isinstance(node, ast.Assign) + and any(isinstance(t, ast.Name) and t.id == "C" for t in node.targets)] + assert gate == (((1, 1), (1, -1)), ((1, -1), (1, 1))) + sources = json.loads(read("inputs/7113-SHA256.json")) + assert sources["replay/supplier7112/short-caller/signed_child.py"] == PINS["inputs/7113-signed-child.py"] + assert sources["replay/supplier7112/short-caller/upstream_application.py"] == PINS["inputs/7113-application.py"] + assert sources["expected/ODD-TYPE-AB-CALLER.json"] == PINS["inputs/CALLER.json"] + application = read("inputs/7113-application.py").decode() + assert "body = terms((1 << j, 1) for j in range(9+8*(stage-1), 9+8*stage))" in application + assert "rank = 8*len(selected); idle_uses += len(kind['ports'])" in application + caller = json.loads(read("inputs/CALLER.json")) + p = caller_projector(caller) + + # Diagonalize the identical responses on each of the two independent + # active lanes. Direct sums add ranks on arbitrary dirty inputs. + phases = physical_response(gate) + modes = 512 + one_lane_rank = modes - phases[0] + finite_rank = 2*one_lane_rank + assert phases == [2*sum(comb(8, k) for k in range(j, 9, 4)) for j in range(4)] + floor = 2*(Q(3, 4)-Q(1, 2**5)) + assert Q(finite_rank, modes) == floor == Q(23, 16) + + old = json.loads(read("inputs/R92-PRICE.json")) + assert old["head"] == HEAD and old["caller_head"] == CALLER + read("inputs/pricing.py") + q = run_path(str(HERE/"inputs/pricing.py")) + assert b"volume-linear new charge" in read("inputs/7397-PROOF.md") + k = Q(old["old_crossing_upper"]) + h8, h16 = (q["power_bounds"](r, k) for r in (8, 16)) + affordable = 2*h8[1]/h16[0] + raw_upper = 8*(2*h8[1]-floor*h16[0]) + assert affordable < Q(1003, 1000) < floor + assert raw_upper < -55 + canonical_floor = floor/(Q(3, 4)+Q(1, 2**9)) + assert canonical_floor == Q(736, 385) + alarm(0) + print(json.dumps({ + "benchmark": HEAD, "caller": CALLER, "stage": 17, "ports": PORTS, + "clocks": CLOCKS, "physical_stage_axes": list(range(137, 145)), + "scope": "unchanged identity-erased bypass; one field; volume-linear tariff", + "pins": PINS, "projector": [[str(x) for x in row] for row in p], + "tested_responses": ["literal physical D17", "fixed erased I"], + "basis_columns_per_lane": modes, "lane_count": 2, + "eigenphase_counts_per_lane": phases, + "one_lane_displacement_rank": one_lane_rank, + "combined_displacement_rank": finite_rank, + "volume_lower_all_widths": str(floor), + "rank16_affordability_upper": str(affordable), + "eight_port_raw_delta_upper": str(raw_upper), + "rank16_canonical_fourth_root_phase_volume_lower": str(canonical_floor), + "negative_controls": ["duplicate projector has nonzero product", "omitted body axis fails on Walsh minus input"], + "runner_cap_seconds": 45, + }, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-stage17-two-return-volume-bound/inputs/7113-SHA256.json b/research/p104-stage17-two-return-volume-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-stage17-two-return-volume-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-two-return-volume-bound/inputs/7113-application.py b/research/p104-stage17-two-return-volume-bound/inputs/7113-application.py new file mode 100644 index 0000000000..1a6d358cbe --- /dev/null +++ b/research/p104-stage17-two-return-volume-bound/inputs/7113-application.py @@ -0,0 +1,369 @@ +#!/usr/bin/env python3 +"""Exact-source caller geometry, occurrence allocation and rational BIT frames. + +No contributor scientific module is imported. Complex phase-polynomial +method credited to the retained fragment physical audit; here coefficients +of the full degree-two polynomial are constructed instead of probing it. +OpenAI Codex assistance for Douglas Colkitt. Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + raw = (ROOT / path).read_bytes() + pin = next(p for p in json.loads((HERE / 'SOURCES.json').read_text())['files'] + if p['path'] == path) + need(sha256(raw).hexdigest() == pin['sha256'], 'source bytes: ' + path) + return json.loads(gzip.decompress(raw) if path.endswith('.gz') else raw) + + +def digest(value): + return sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def bits(n): + result = [] + while n: + a = n & -n + result.append(a) + n ^= a + return result + + +def dot(a, b): + return (a & b).bit_count() % 2 + + +def terms(items): + c = Counter() + for v, a in items: + c[v] += a + return {v: a % 4 for v, a in c.items() if v and a % 4} + + +def sub(a, b): + return terms(list(a.items()) + [(v, -c) for v, c in b.items()]) + + +def polynomial(t): + # parity(sum x_i) = sum x_i - 2 sum_{i 0, 'positive complete helper job') + T[rank] += 1 + need(len(mapping) == len(set(mapping.values())) == word['public'], 'injective native inputs') + for r in range(word['public'], word['public']+word['owned_fields']): + mapping[r] = ('owned', ci, r-word['public']) + need(len(set(mapping.values())) == word['public']+51, 'owned/public separation') + for ni, move in native_moves: + _, r, start, end, owned = move + rank = abs(len(word['frames'][end])-len(word['frames'][start])) + need(owned == (r >= word['public']) and rank > 0, 'actual paid owner class') + P[rank] += 1 + occurrences.append([ci, ni, list(mapping[r]), rank, start, end]) + for pi, q in enumerate(word['ports']): + transform = route(q, by_q[q], stage) + before_axes = [1 << j for j in range(9+8*(stage-1))] + after_axes = [1 << j for j in range(9+8*stage)] + spectator = [1 << j for j in range(9, 9+8*stage)] + x0 = terms((a, 1) for a in before_axes) + y0 = terms(list(x0.items())+[(q, -1)]) + x1 = terms((a, 1) for a in after_axes) + y1 = terms(list(x1.items())+[(q, -1)]) + nx0 = terms([(a, 1) for a in spectator]+[(q, 1)]) + ny0 = terms((a, 1) for a in spectator) + nx1 = terms((a, 1) for a in spectator+[1 << j for j in range(9)]) + ny1 = terms(list(nx1.items())+[(q, -1)]) + shifts = [boundary(a, b, transform) for a, b in + ((x0, nx0), (y0, ny0), (nx1, x1), (ny1, y1))] + body = terms((1 << j, 1) for j in range(9+8*(stage-1), 9+8*stage)) + for actual, expected in ((sub(x1,x0),body), (sub(y1,y0),body), + (sub(y1,x0),terms(list(body.items())+[(q,-1)])), + (sub(x1,y0),terms(list(body.items())+[(q,1)]))): + need(not polynomial(sub(actual,expected)), 'all four contact operators') + need(polynomial(sub(terms([(q,1)]),terms([(q,-1)]))), 'wrong query orientation rejected') + phase_records.append([ci,pi,shifts,2 if pi in second else 1]) + else: + ty, op, r, *a = e + kind = caller['types'][ty] + used = [r] + ([a[0]] if op in ('ADD','SWAP','QUERY') else []) + need(all(kind['offset'] <= x < kind['offset']+kind['roles'] for x in used), 'caller owners stay in type') + need(len(used) == len(set(used)), 'distinct scalar/query owners') + if op in ('QUERY','IDLE_ONE'): + if op == 'QUERY': + need(a[1] in (-1,1), 'signed completed query') + rank = 1; query_uses += len(kind['ports']) + else: + selected = a[0] + need(selected and len(selected)==len(set(selected)) + and all(1 <= s <= 18 for s in selected), 'whole idle stage axes') + rank = 8*len(selected); idle_uses += len(kind['ports']) + for pi in kind['ports']: + owner = ['query_scratch',ci,pi] if op == 'QUERY' else ['main',pi,r] + occurrences.append([ci,op,owner,rank]); P[rank] += 1 + elif op == 'LAMBDA': + need(a[0] in (-1,1), 'global normalizer sign') + lambda_uses += len(kind['ports']) + need(stage_order == list(range(1,19)), 'fresh chronological native stages') + for kind in caller['types'].values(): + for diagonal in kind['diagonal']: + qp, zero, *selection = diagonal + need(qp in (-1,0,1) and zero == 0 and len(selection)==18 + and set(selection)<={0,1} and any(selection), 'positive nonempty root endpoint') + rank = abs(qp)+8*sum(selection) + for pi in kind['ports']: + q = word['ports'][pi] + axes = [1 << (9+8*j+k) for j,yes in enumerate(selection) if yes for k in range(8)] + actual = terms([(q,qp)]+[(a,1) for a in axes]) + target = terms((a,1) for a in ([q] if qp else [])+axes) + need(translation(sub(target,actual)) == (q if qp == -1 else 0), 'whole output correction') + T[rank] += 1 + for name, actual in [('P',P),('T',T)]: + need(actual == Counter({int(k):v for k,v in receipt['invoice'][name].items()}), 'independent '+name+' invoice') + need(sum(T.values()) == len(owners), 'every productive target is one actual owner') + need(len(occurrences) == sum(P.values()), 'every paid position retained in order') + return dict(ambient=153, native_calls=18, native_public=1480, fresh_helpers=19440, + productive_fields=len(owners), paid_positions=len(occurrences), + complete_paid_position_digest=digest(occurrences), + native_contact_boundaries=sum(4*r[3] for r in phase_records), + phase_record_digest=digest(phase_records), nonzero_boundary_translations=sum(sum(bool(x) for x in r[2])*r[3] for r in phase_records), + reserved_native_banks=18*51, reserved_serial_query_lambda_bank=1, + query_uses=query_uses, idle_uses=idle_uses, lambda_uses=lambda_uses, + paid=dict(sorted(P.items())), targets=dict(sorted(T.items())), + rank_surplus=sum(r*T[r] for r in T)-sum(r*P[r] for r in P)) + + +def inverse(matrix): + n = len(matrix) + a = [[Q(x) for x in row]+[Q(i==j) for j in range(n)] for i,row in enumerate(matrix)] + det = Q(1) + for j in range(n): + pivot = next((i for i in range(j,n) if a[i][j]),None) + need(pivot is not None, 'rational basis invertible') + if pivot != j: + a[j],a[pivot] = a[pivot],a[j]; det = -det + v = a[j][j]; det *= v; a[j] = [x/v for x in a[j]] + for i in range(n): + if i != j: + v = a[i][j] + a[i] = [x-v*y for x,y in zip(a[i],a[j])] + return [row[n:] for row in a], det + + +def bit_application(word, caller, receipt): + ff = word['frames']; determinants=[]; denominator_witnesses=set() + for label, frame in ff.items(): + B,A = frame['B'],frame['A']; d = frame['dim'] + need(len(B)==d and len(A)==8-d and all(len(v)==8 for v in B+A), 'rational frame dimensions') + need(all(sum(Q(x)*Q(y) for x,y in zip(b,a))==0 for b in B for a in A), 'complement annihilation') + inv, det = inverse(list(zip(*(B+A)))) + determinants.append([label,str(det)]) + denominator_witnesses.add(abs(det.numerator)); denominator_witnesses.add(det.denominator) + for row in inv: + denominator_witnesses.update(x.denominator for x in row) + for row in B+A: + denominator_witnesses.update(Q(x).denominator for x in row) + charts=[] + for port in range(111): + head=ff[str(word['start'][port])]; body=ff[str(word['final'][port+111])] + need(head['dim']==1 and body['dim']==7, 'actual main head/body ranks') + u=head['B'][0] + need(all(sum(Q(x)*Q(y) for x,y in zip(u,v))==0 for v in body['B']), 'main complement') + inv,det=inverse(list(zip(*([u]+body['B'])))) + charts.append([port,str(det)]) + denominator_witnesses.update([abs(det.numerator),det.denominator]) + for row in inv:denominator_witnesses.update(x.denominator for x in row) + P,T=Counter(),Counter(); positions=[]; names={('main',pi,r) for pi in range(111) for r in range(38)} + calls=[] + for ci,e in enumerate(caller['events']): + op=e[0] + if op=='LOCAL': + _,stage,src,dst=e; calls.append(stage) + mapping={i:('main',i,src) for i in range(111)} + mapping.update({i+111:('main',i,dst) for i in range(111)}) + for r in range(222,word['public']): + owner=('helper',ci,r); need(owner not in names,'fresh BIT helper');names.add(owner);mapping[r]=owner + T[abs(ff[str(word['start'][r])]['dim']-ff[str(word['final'][r])]['dim'])]+=1 + need(len(mapping)==len(set(mapping.values()))==659,'injective BIT occurrence') + for r in range(659,659+word['owned_fields']):mapping[r]=('owned',ci,r-659) + for ni,move in enumerate(word['program']): + if move[0]=='MOVE': + _,r,a,b=move;rank=abs(ff[str(a)]['dim']-ff[str(b)]['dim']) + P[rank]+=1;positions.append([ci,ni,list(mapping[r]),rank,a,b]) + elif op=='QUERY': + need(e[1]!=e[2] and 0<=min(e[1:])<=max(e[1:])<38,'BIT query owners') + for pi in range(111):P[1]+=1;positions.append([ci,op,['query_scratch',ci,pi],1]) + elif op=='IDLE_ONE': + _,owner,ss=e;need(ss and len(ss)==len(set(ss)) and all(1<=s<=18 for s in ss),'BIT idle axes') + for pi in range(111):P[7*len(ss)]+=1;positions.append([ci,op,['main',pi,owner],7*len(ss)]) + need(calls==[s for s in range(1,19) for _ in range(2)],'paired native chronology') + for d in caller['diagonal']: + need(d['q']==1 and d['stages'] and len(d['stages'])==len(set(d['stages'])),'BIT positive endpoint') + T[1+7*len(d['stages'])]+=111 + need(P==Counter({int(k):v for k,v in receipt['paid'].items()}) and + T==Counter({int(k):v for k,v in receipt['targets'].items()}),'complete BIT invoice') + need(sum(T.values())==len(names)==19950,'BIT owner count') + return dict(ambient=134, rational_frames=len(ff), rational_main_charts=len(charts), + rational_determinants_digest=digest(determinants), + finite_prime_exclusion_witness_count=len(denominator_witnesses), + finite_prime_exclusion_witness_digest=digest(sorted(denominator_witnesses)), + native_calls=len(calls), fresh_helpers=36*437, productive_fields=len(names), + paid_positions=len(positions), complete_paid_position_digest=digest(positions), + reserved_native_banks=36*word['owned_fields'], reserved_serial_query_bank=1, + rank_surplus=sum(r*T[r] for r in T)-sum(r*P[r] for r in P)) + + +def main(): + p='research/shared-wire-split-composition/' + w,c,r=read(p+'data/final.json.gz'),read(p+'data/caller.json'),read(p+'FULL-RESULT.json') + phases=read('research/p104-two-chain-shared-native/retained/runtime/DATA-PHASES.json') + complex_result=complex_application(w,c,r,phases) + p='research/paired-query-only-bit/' + bw,bc,br=read(p+'retained/inputs/BIT-NATIVE-WORD.json.gz'),read(p+'EFREE-CALLER.json.gz'),read(p+'EFREE-RESULT.json') + bit_result=bit_application(bw,bc,br) + controls={} + def reject(name, action): + try:action() + except ValueError as error:controls[name]=str(error) + else:raise ValueError('negative control accepted: '+name) + alias=deepcopy(c);joint=next(e for e in alias['events'] if e[0]=='J');joint[2][2]=joint[2][0] + reject('same_frame_main_alias',lambda:complex_application(w,alias,r,phases)) + reordered=deepcopy(c);joint=next(e for e in reordered['events'] if e[0]=='J');joint[1]=2 + reject('wrong_stage',lambda:complex_application(w,reordered,r,phases)) + bad_bit=deepcopy(bw);bad_bit['frames']['0']['A'][1]=bad_bit['frames']['0']['A'][0][:] + reject('singular_BIT_spectator_basis',lambda:bit_application(bad_bit,bc,br)) + q=w['ports'][0];basis=next(x for x in phases['recipes'] if x['q']==q)['idle_children'][0]['orthogonal_axes'][:8] + reject('singular_complex_route',lambda:route(q,basis[:-1]+basis[:1],1)) + transform=route(q,basis,1) + before=terms((1<> (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< 2 + + caller = tmp/"inputs/CALLER.json" + caller.write_bytes(caller.read_bytes()+b" ") + execute(tmp/"tensor_columns.py", succeeds=False) + print(dumps({"authenticated_receipts":2, "mutated_caller_rejected":True, + "physical_rank":736, "per_lane_columns":512, "kappa_delta":"0"}, sort_keys=True)) + print("PASS_P104_STAGE17_TWO_RETURN_VOLUME_BOUND") + + +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") + parser = ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path) + args = parser.parse_args() + with TemporaryDirectory(prefix="p104-stage17-volume-") as d: + replay(Path(d), args.out) + + +if __name__ == "__main__": + main()