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 79fed9d6765d1b921b8d5e547af301310a9e259e Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Thu, 12 Nov 2026 03:27:55 -0800 Subject: [PATCH 3/3] Bound the retimed Type A stage-8 host --- .../LOCAL-PINS.json | 17 + .../NOTICE | 3 + .../PROOF.md | 76 + .../PROVENANCE.json | 99 + .../README.md | 57 + .../SOURCES.json | 18 + .../TASK.json | 117 + .../VERIFICATION.md | 16 + .../VERIFY.json | 14 + .../engines/host_forward.py | 225 ++ .../engines/host_reverse.py | 123 + .../inputs/7113-SHA256.json | 69 + .../inputs/7113-application.py | 369 +++ .../inputs/7113-signed-child.py | 146 + .../inputs/CALLER.json | 1 + .../inputs/PHYSICAL-BINDING.json | 64 + .../inputs/PR7362-SHA256.json | 11 + .../inputs/PR7404-RESULT.json | 2320 +++++++++++++++ .../inputs/R92-PRICE.json | 2539 +++++++++++++++++ .../inputs/pricing.py | 82 + .../receipts/R174-FORWARD.json | 143 + .../receipts/R174-PRICE.json | 72 + .../receipts/R174-REVERSE.json | 87 + .../replay.py | 197 ++ 24 files changed, 6865 insertions(+) create mode 100644 research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/NOTICE create mode 100644 research/p104-retimed-type-a-stage8-host-bound/PROOF.md create mode 100644 research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/README.md create mode 100644 research/p104-retimed-type-a-stage8-host-bound/SOURCES.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/TASK.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md create mode 100644 research/p104-retimed-type-a-stage8-host-bound/VERIFY.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py create mode 100644 research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/7113-SHA256.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/7113-application.py create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/7113-signed-child.py create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/CALLER.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/PHYSICAL-BINDING.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/PR7362-SHA256.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/PR7404-RESULT.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/R92-PRICE.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/inputs/pricing.py create mode 100644 research/p104-retimed-type-a-stage8-host-bound/receipts/R174-FORWARD.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/receipts/R174-PRICE.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/receipts/R174-REVERSE.json create mode 100644 research/p104-retimed-type-a-stage8-host-bound/replay.py diff --git a/research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json b/research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..87e40c3f47 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json @@ -0,0 +1,17 @@ +{ + "PROVENANCE.json": "fca52d8864312b65f12f0eee2f062dbebc12dc9d18050df8b29e98a05712e43a", + "engines/host_forward.py": "3f22de2c9f9e53e194b9244df4d3562f0c3f1199b63b91f76e8d3732bb818e99", + "engines/host_reverse.py": "ca5cb7a13b5bffebc7213e677252845edb1a1019e9ad3ee187a3eb6c57569fd9", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "inputs/PR7362-SHA256.json": "2c90ca39b0f075cc4b3ec9e90c66fde473465e7bb50cf1db9a820d3a29556c0b", + "inputs/PR7404-RESULT.json": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/R174-FORWARD.json": "e870a1c386581b11dd2231b657b7e0dc5e3c67eafb51bc7650f853bf22581fd1", + "receipts/R174-PRICE.json": "eb5ba68fe579cfea3ae1c79782850f173bc6e06fb853ce152bf58d7d6ed507b1", + "receipts/R174-REVERSE.json": "686d9ff864fb1305d66a953db99cce3a0ce7dbf1adfaf338c4072a84e638545f" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/NOTICE b/research/p104-retimed-type-a-stage8-host-bound/NOTICE new file mode 100644 index 0000000000..1d19be7778 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/NOTICE @@ -0,0 +1,3 @@ +Apache-2.0 contribution. The exact #7404 result is attributed to Clear1nsight. +See README.md and PROVENANCE.json for predecessor sources and original credit. +OpenAI Codex and subagents materially assisted the proof and independent replay. diff --git a/research/p104-retimed-type-a-stage8-host-bound/PROOF.md b/research/p104-retimed-type-a-stage8-host-bound/PROOF.md new file mode 100644 index 0000000000..aa518579c8 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/PROOF.md @@ -0,0 +1,76 @@ +# A fixed four-field host cannot realize the requested retimed action + +## Scope + +Keep the first Type A port on exact #7334 and #7113. The pinned #7404 +retiming hoists 14 paid idles and cancels 28 scalar ADDs around the +stage-8 J at zero-based clock 1423. Its physical host roles are +(8,0,18,26), bound to native labels (0,112,772,882). +Demote the two QUERYs at 1580 and 1659 to unit ADDs. +The requested productive endpoint removes the central q factor +from roles 0 and 18 and retains every other target. + +On the compared phase and body sectors, grant an arbitrary replacement +host of the form $C+WKV$. The feedthrough $C$ and linear output and +input adapters $W,V$ are independent of the stage-8 body and have +the same normalized action at both central signs. The input and +output host interfaces each have dimension four on those sectors. +The other events remain the exact retimed and demoted skeleton. + +## Required matrices + +Let $P$ and $S$ denote the retimed prefix and demoted suffix, and +$T$ the requested whole endpoint. All three are read at each +specialization. The only possible replacement host is +$S^{-1}TP^{-1}$. Forward matrices check both inverse maps and +the complete reconstructed endpoint. Reverse covectors give +a separate exact computation of the required rows. + +At $q=+1$, the required host is exactly the old J8 for both +$B_8=+1$ and $B_8=-1$, with all other bodies set to one. Their +difference is supported on the old four-role block and its +determinant there is 16. For the granted factorization the +same difference is $W(K_- - K_+)V$. Its column space is contained +in that of $W$ and its row space in that of $V$. Rank four +forces both these spaces to be precisely the old four-role +coordinate spaces. At unit bodies the central sign difference +must then be supported in the same block, since $C,W,V$ are +unchanged across those signs. + +The exact comparison of $q=-1$ and $q=+1$ at unit bodies gives +320 nonzero entries outside the block. In particular, entry +(8,1) equals −2. This violates the necessary support condition +for the tested root pair. + +## Physical signs + +The exact #7113 binding separates the central direction from +the eight fresh stage-8 axes, zero-based axes 65 through 72. +At column multiplicity at least two, the binary gate $C_0$ acts +on each replicated axis with Walsh eigenvalues 1 and $i$, +certified on the integer vectors $(1,1)$ and $(1,-1)$. +Choose all plus Walsh vectors for a positive response. Choose +two minus vectors in the central tensor axis for $q=-1$, or +two minus vectors in the stage-8 body for $B_8=-1$. +The selected factors multiply to $i^2=-1$ and every other +factor remains one. The central direction and all stage +blocks are disjoint. This supplies the three physical sectors +used by the matrix obstruction, with arbitrary linear role +coefficients on each sector. + +## Price and residual scope + +Before charging any new work, one port removes two rank-one paid +QUERYs and lowers two productive ranks from 137 to 136. +The exact directed gross upper is 0.04270044187346692 raw at the +old crossing. The inherited probe has a complete lower margin +above 0.04231287836140672 in that optimistic model. A 96-port +relaxation has gross upper 4.099242419852824 and does not establish +compatibility at any additional port. An extra rank-one paid +field cannot fit the one-port saving. + +The exact four-role gate fails. No edited native host, restoration, +compiler, rounding or full new caller application was needed. +A changed feedthrough or adapter across the compared sectors, +more ingress or egress fields, another root pair or a different +retiming requires separate evidence. diff --git a/research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json b/research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json new file mode 100644 index 0000000000..544abf6bb3 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json @@ -0,0 +1,99 @@ +{ + "comparator": { + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "pull_request": 7334, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334", + "status": "strongest independently reproduced complete comparable witness" + }, + "derived_inputs": { + "inputs/R92-PRICE.json": { + "key": "R92-PRICE.json", + "receipt": "inputs/PR7362-SHA256.json" + } + }, + "files": { + "inputs/7113-SHA256.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "5a7d6b80dc51aa918a5d521b60d18f9a6bbbc52e", + "path": "research/signed-caller-8x9/SHA256.json", + "sha256": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "source": "https://github.com/rohanarun/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/rohanarun/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/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/replay/supplier7112/short-caller/signed_child.py" + }, + "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/rohanarun/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/rohanarun/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/PR7404-RESULT.json": { + "commit": "aadd1de3e520cfd1e5b062729bd76f543dc879f4", + "git_blob": "d9b84899429576280cc0052a6670686cbcdabcc7", + "path": "research/p104-stage8-query-carrier/RESULT.json", + "sha256": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", + "source": "https://github.com/Clear1nsight/integer-mult-bounds/blob/aadd1de3e520cfd1e5b062729bd76f543dc879f4/research/p104-stage8-query-carrier/RESULT.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" + } + }, + "peer7404": { + "author": "Clear1nsight", + "exact_prior_source_pins": [ + [ + "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json", + "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" + ], + [ + "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "research/p104-helper-319-fused-return/WORD.json.gz", + "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a" + ], + [ + "b567f9a4f5699c5e447100c38b5745526b15b770", + "research/p104-type-a-query-fixed-cut/engines/lead/full_body.py", + "352c7d594f357333f027dc46eef0e82226b9552ab31d6890b1695fe994e8c3b4" + ], + [ + "ebb2b1c5b62344f56c62d526558f059c99dd7077", + "research/p104-paired-query-host-rank-bound/engines/host_rank.py", + "ffbcde67a1f0a7595233baf0e5b40e73ab75fe1324139ecf374040a88d62a13e" + ] + ], + "head": "aadd1de3e520cfd1e5b062729bd76f543dc879f4" + }, + "schema_version": 1 +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/README.md b/research/p104-retimed-type-a-stage8-host-bound/README.md new file mode 100644 index 0000000000..14ec6436aa --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/README.md @@ -0,0 +1,57 @@ +# Bound the retimed Type A stage-8 host + +**NO VERIFIED GAIN.** Keep the exact [#7404](https://github.com/CrocSwap/integer-mult-bounds/pull/7404) +retiming at the first Type A port, demote QUERYs 1580 and 1659 to unit ADDs, +and request retirement of the central phase on productive roots 0 and 18. +The required stage-8 host cannot fit four ingress and four egress fields +with fixed phase-even adapters and feedthrough on the compared sectors. +At central sign +1, the body difference has determinant 16 on the original +four-role block. The central sign difference has 320 entries outside that +block, including (8,1) = −2. + +The comparison uses [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) +at aaeec8c0acf01e99a5f331ef363a698d9c084ace and the signed +[#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +caller at 07a76c5e2738882c0cb322278e56f6cae3c9885d. The strongest reproduced +comparable exponent saving remains 0.00364665195644. + +The one-port optimistic price was positive before the support check, +below 0.04270044187346692 raw. A 96-port relaxation assuming compatibility +is below 4.099242419852824 raw. The verified exclusion is for this exact +port, one J clock and one root pair. See [proof and scope](PROOF.md). + +From a clean checkout with CPython 3.12 and assertions, run + + python3.12 -I -B research/p104-retimed-type-a-stage8-host-bound/replay.py + +The replay binds the exact public inputs and reproduces the directed +price, forward matrices and independent reverse-covector receipt. +It also checks the physical sign witnesses and rejects altered caller +bytes. See [verification](VERIFICATION.md) and [provenance](PROVENANCE.json). + +## Open next questions + +Can an enlarged or phase-dependent host implement both aggregate reads, +the scatter and the dirty-input return contract under the same paid bill? +Start with one specified extra ingress or egress path at clock 1423. +Check its support, chronological availability and unchanged returns, +then price all new fields and adapters. Other root pairs, other clocks, +odd feedthrough and different skeletons were outside the test. + +## Credit + +Clear1nsight's [#7404](https://github.com/CrocSwap/integer-mult-bounds/pull/7404) +at aadd1de3e520cfd1e5b062729bd76f543dc879f4 supplies the exact 14-idle +retiming and the original carrier evidence. The retained signed caller +and native comparator are credited to Rohan Arun's +[#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) and +Clear1nsight's [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334). +[#7401](https://github.com/CrocSwap/integer-mult-bounds/pull/7401) supplies +the fixed-skeleton two-root comparison, and +[#7344](https://github.com/CrocSwap/integer-mult-bounds/pull/7344) the +retained-J phase capacity question. +[#7360](https://github.com/CrocSwap/integer-mult-bounds/pull/7360) +supplies the physical character witness method, and +[#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) +the exact price receipt. OpenAI Codex and subagents materially assisted +the proof, implementation and independent verification. Apache-2.0. diff --git a/research/p104-retimed-type-a-stage8-host-bound/SOURCES.json b/research/p104-retimed-type-a-stage8-host-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-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-retimed-type-a-stage8-host-bound/TASK.json b/research/p104-retimed-type-a-stage8-host-bound/TASK.json new file mode 100644 index 0000000000..30366b877b --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113, Clear1nsight #7404 retiming at Type A port 0, J8 at 1423, and demotion 1580/1659 with retirement only at roots 0 and 18.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 retimed Type A stage-8 host research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "The two removed rank-one jobs save the binding moment only if the same paid host can realize the requested new arbitrary-input endpoint.", + "budget_minutes": 12, + "evidence": "Independent 36-column forward and reverse checks find determinant 16 on the old body support and 320 entries outside the corresponding phase support.", + "open_questions": [ + { + "blocked_by": "No legal larger interface and complete invoice are known in this test.", + "first_step": "Specify one extra ingress or egress path at the tested J clock and check arbitrary dirty ownership, restoration, and full price.", + "question": "Can an enlarged or phase-dependent host deliver the two aggregates and scatter with the same paid bill?", + "why_it_matters": "The four-field even interface cannot realize the optimistic paid saving." + } + ], + "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 a different productive endpoint within the exact peer retiming and a four-field even host interface.", + "scope_status": "changed", + "stop_rule": "One port, one root pair, one J, two central signs, one extra body setting and 36 columns, at most 10 seconds per support engine.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md b/research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md new file mode 100644 index 0000000000..bd6935af11 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md @@ -0,0 +1,16 @@ +# Verification record + +The exact first-port test uses one root pair, one J clock, 36 basis +columns and the two central signs. The positive central sign has two +stage-8 body settings. The lead checks both old and retimed whole words +and all reconstructed required hosts. A reverse-covector replay uses +row action and independently finds 320 nonzero outside entries and matches +the twelve printed witnesses. Each support runner is capped at ten +seconds. No further root pair or physical build was launched. + +The clean wrapper authenticates exact caller and predecessor bytes by +path, reproduces the price and both support receipts, checks legal +physical sign witnesses from the pinned binary gate and rejects changed +caller bytes. A restoration of one canceled ADD also fails the retimed +endpoint test. The four-field support result is exact in the stated +fixed-sector interface. diff --git a/research/p104-retimed-type-a-stage8-host-bound/VERIFY.json b/research/p104-retimed-type-a-stage8-host-bound/VERIFY.json new file mode 100644 index 0000000000..6e14c60893 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Rebuild the exact one-port price, forward and reverse host matrices and physical sign controls.", + "timeout_seconds": 50 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py b/research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py new file mode 100644 index 0000000000..c169df804c --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py @@ -0,0 +1,225 @@ +"""Price and test one #7404 retimed host with two productive q retirements.""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "PR7404-RESULT.json": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", + "R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} +HOST, QUERIES, BOUND, N = 1423, {1580, 1659}, (8, 0, 18, 26), 36 +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER_HEAD = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +PEER_HEAD = "aadd1de3e520cfd1e5b062729bd76f543dc879f4" + + +def read(name): + path = ROOT / "inputs" / name + raw = path.read_bytes() + assert sha256(raw).hexdigest() == PINS[name], name + return raw + + +def identity(sign=1): + return [[Q(sign if i == j else 0) for j in range(N)] for i in range(N)] + + +def multiply(left, right): + return [[sum(a * b for a, b in zip(row, col, strict=True) if a and b) + for col in zip(*right, strict=True)] for row in left] + + +def difference(left, right): + return [[a - b for a, b in zip(x, y, strict=True)] for x, y in zip(left, right, strict=True)] + + +def tape(events, q, body8, demote=False, inverse=False): + rows = identity() + + def add(dest, src, scale): + rows[dest] = [a + scale * b for a, b in zip(rows[dest], rows[src], strict=True)] + + def scale(role, multiplier): + rows[role] = [x * multiplier for x in rows[role]] + + orient = -1 if inverse else 1 + for clock, event in reversed(events) if inverse else events: + if event[0] == "B": + continue + if event[0] == "J": + _, stage, (u, v, x, y), _ = event + add(v, u, Q(orient * q)) + add(x, y, Q(-orient * q)) + if stage == 8: + for role in (u, v, x, y): + scale(role, body8) + continue + assert event[0] == "A" + _, op, role, *args = event + if op == "ADD": + add(role, args[0], orient * Q(args[1])) + elif op == "QUERY": + assert args[1] == -1 + factor = 1 if demote and clock in QUERIES else q + add(role, args[0], Q(orient * factor)) + elif op == "SCALE": + scale(role, Q(args[0]) ** orient) + elif op == "SWAP": + other, = args + rows[role], rows[other] = rows[other], rows[role] + elif op == "IDLE_ONE": + mask, = args + if 8 in mask: + scale(role, body8) + else: + assert op == "LAMBDA" + return rows + + +def retiming(events, peer): + assert events[HOST][:3] == ["J", 8, list(BOUND)] + assert peer["stage_host"] == HOST and set(peer["queries"]) == QUERIES + assert peer["native_role_binding"] == {"8": 0, "0": 112, "18": 772, "26": 882} + assert all(events[k] == ["A", "QUERY", 0, 1, -1] for k in QUERIES) + moved = peer["hoisted_paid_idles"] + assert len(moved) == 14 + omitted = set() + hoisted = [] + for item in moved: + role, mask, clock = item["role"], item["mask"], item["idle"] + assert HOST < clock <= 1487 and 8 in mask and role not in BOUND + assert events[clock] == ["A", "IDLE_ONE", role, mask] + early, late = item["canceled_adds"] + donor = 0 if role < 18 else 18 + assert HOST < early < late < clock + assert events[early] == ["A", "ADD", role, donor, "2"] + assert events[late] == ["A", "ADD", role, donor, "-2"] + omitted.update((early, late, clock)) + hoisted.append((clock, events[clock])) + assert len(omitted) == 42 + indexed = list(enumerate(events)) + before = indexed[:HOST] + hoisted + after = [(i, event) for i, event in indexed[HOST + 1:] if i not in omitted] + return indexed, before, after + + +def outside(matrix): + return [(i, j, value) for i, row in enumerate(matrix) + for j, value in enumerate(row) if value and (i not in BOUND or j not in BOUND)] + + +def determinant(matrix): + work = [row.copy() for row in matrix] + value = Q(1) + for col in range(len(work)): + pivot = next((k for k in range(col, len(work)) if work[k][col]), None) + if pivot is None: + return Q(0) + if pivot != col: + work[pivot], work[col] = work[col], work[pivot] + value = -value + entry = work[col][col] + value *= entry + for k in range(col + 1, len(work)): + ratio = work[k][col] / entry + work[k] = [a - ratio * b for a, b in zip(work[k], work[col], strict=True)] + return value + + +def quote(caller, roots): + base = json.loads(read("R92-PRICE.json")) + assert base["head"] == HEAD and base["caller_head"] == CALLER_HEAD + pricing = ROOT / "inputs" / "pricing.py" + read("pricing.py") + cost = run_path(str(pricing))["cost"] + type_a = caller["types"]["A"] + ranks = [1 + 8 * sum(row[2:]) for row in type_a["diagonal"]] + ports = len(type_a["ports"]) + assert type_a["roles"] == N and type_a["alpha2"] == "-1" and ports == 96 + crossing = Q(base["old_crossing_upper"]) + stock = Counter({int(r): n for r, n in base["old_targets"].items()}) + stock.subtract({int(r): n for r, n in base["old_paid"].items()}) + results = {} + for count in (1, ports): + delta = Counter({1: 2 * count}) + for root in roots: + delta[ranks[root]] -= count + delta[ranks[root] - 1] += count + assert sum(r * n for r, n in delta.items()) == 0 + edited = stock.copy() + edited.update(delta) + results[count] = { + "signed_histogram_delta": delta, + "gross_at_crossing_upper": cost(delta, crossing), + "complete_at_crossing_upper": cost(edited, crossing), + "complete_at_probe": cost(edited, Q(base["probe"])), + } + return {"roots": roots, "target_ranks": [ranks[r] for r in roots], "ports": results} + + +def stop(*_): + raise TimeoutError("10-second exact gate cap") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--price-only", action="store_true") + args = parser.parse_args() + assert __debug__ + signal(SIGALRM, stop) + alarm(10) + caller = json.loads(read("CALLER.json")) + roots = (0, 18) + pricing = quote(caller, roots) + result = {"native_head": HEAD, "caller_head": CALLER_HEAD, "peer_head": PEER_HEAD, + "caps": {"target_pairs": 1, "phases": 2, "basis_columns": 36, "seconds": 10}, + "host": HOST, "demote_queries": sorted(QUERIES), "price": pricing, "pins": PINS} + if not args.price_only: + events = caller["events"] + assert len(events) == 4783 + indexed, prefix, suffix = retiming(events, json.loads(read("PR7404-RESULT.json"))) + required = {} + original_host = [(HOST, events[HOST])] + for q, body8 in ((1, 1), (1, -1), (-1, 1)): + original = tape(indexed, q, body8) + if body8 == 1: + assert original == identity(q) + pre = tape(prefix, q, body8) + post = tape(suffix, q, body8) + j = tape(original_host, q, body8) + assert multiply(post, multiply(j, pre)) == original + post_demoted = tape(suffix, q, body8, demote=True) + inverse_post = tape(suffix, q, body8, demote=True, inverse=True) + inverse_pre = tape(prefix, q, body8, inverse=True) + assert multiply(post_demoted, inverse_post) == multiply(pre, inverse_pre) == identity() + if q == -1: + for role in roots: + original[role] = [-x for x in original[role]] + need = multiply(inverse_post, multiply(original, inverse_pre)) + assert multiply(post_demoted, multiply(need, pre)) == original + if q == 1: + assert need == j + required[q, body8] = need + body_delta = difference(required[1, -1], required[1, 1]) + assert not outside(body_delta) + body_minor = determinant([[body_delta[i][j] for j in BOUND] for i in BOUND]) + assert body_minor + phase_delta = difference(required[-1, 1], required[1, 1]) + nonzero = outside(phase_delta) + result.update({"bound": BOUND, "body_minor": body_minor, + "outside_nonzero_count": len(nonzero), "first_outside_entries": nonzero[:12], + "decision": "EXCLUDED by four-role support" if nonzero else "SURVIVES support only"}) + alarm(0) + print(json.dumps(result, indent=2, sort_keys=True, default=str)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py b/research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py new file mode 100644 index 0000000000..301b1501a2 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py @@ -0,0 +1,123 @@ +"""Reverse-covector check of one retimed Type A host support.""" +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PR7404-RESULT.json": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", +} +HOST = (8,0,18,26) +CLOCK = 1423 +QUERIES = (1580,1659) +N = 36 + + +def load(name): + raw = (ROOT/name).read_bytes() + assert sha256(raw).hexdigest() == PINS[name] + return loads(raw) + + +def right_inverse(row, word, q, body, demote): + for clock, event in word: + ty = event[0] + if ty == "B": + continue + if ty == "J": + _, stage, (u,v,x,y), _ = event + row[u] -= q * row[v] + row[y] += q * row[x] + if stage == 8: + for role in (u,v,x,y): + row[role] /= body + continue + _, op, dst, *args = event + if op == "ADD": + src, a = args + row[src] -= Q(a) * row[dst] + elif op == "QUERY": + src, phase = args + assert phase == -1 + a = 1 if demote and clock in QUERIES else q + row[src] -= a * row[dst] + elif op == "SCALE": + row[dst] /= Q(args[0]) + elif op == "SWAP": + src, = args + row[dst], row[src] = row[src], row[dst] + elif op == "IDLE_ONE": + if 8 in args[0]: + row[dst] /= body + else: + assert op == "LAMBDA" + return row + + +def basis(i): + return [Q(i==j) for j in range(N)] + + +def required(before, after, q, body, wanted): + output = [] + for i in range(N): + row = right_inverse(basis(i), after, q, body, True) + row = [x * sign for x, sign in zip(row,wanted,strict=True)] + output.append(right_inverse(row, before, q, body, False)) + return output + + +def actual_host(q, body): + table = [basis(i) for i in range(N)] + u,v,x,y = HOST + table[v][u] = q + table[x][y] = -q + for r in HOST: + table[r] = [body * a for a in table[r]] + return table + + +def stop(*_): + raise TimeoutError("10-second exact cap") + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(10) + c = load("inputs/CALLER.json") + p = load("inputs/PR7404-RESULT.json") + events = list(enumerate(c["events"])) + assert p["stage_host"] == CLOCK and sorted(p["queries"]) == list(QUERIES) + assert events[CLOCK][1][0:3] == ["J",8,list(HOST)] + skip, moved = set(), [] + for z in p["hoisted_paid_idles"]: + clock = z["idle"] + moved.append(events[clock]) + skip.update([clock,*z["canceled_adds"]]) + assert events[clock][1] == ["A","IDLE_ONE",z["role"],z["mask"]] + assert len(skip) == 42 + before = events[:CLOCK] + moved + after = [x for x in events[CLOCK+1:] if x[0] not in skip] + for q in (1,-1): + for i in range(N): + assert right_inverse(basis(i), events, q, Q(1), False) == [q*x for x in basis(i)] + plus = required(before,after,1,Q(1),[1]*N) + assert plus == actual_host(1,Q(1)) + alt = required(before,after,1,Q(-1),[-1 if d[9] else 1 for d in c["types"]["A"]["diagonal"]]) + assert alt == actual_host(1,Q(-1)) + minus = required(before,after,-1,Q(1),[1 if i in (0,18) else -1 for i in range(N)]) + witness = [[i,j,str(minus[i][j]-plus[i][j])] for i in range(N) for j in range(N) + if (i not in HOST or j not in HOST) and minus[i][j] != plus[i][j]] + alarm(0) + print(dumps({"pins":PINS,"window_host":CLOCK,"host_roles":HOST,"queries":QUERIES, + "retired_roles":[0,18],"outside_nonzero_count":len(witness), + "first_outside_entries":witness[:12],"plus_body_control":"exact old host at both signs of B8", + "hard_cap_seconds":10,"basis_columns":N},sort_keys=True,indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-SHA256.json b/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-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-retimed-type-a-stage8-host-bound/inputs/7113-application.py b/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-application.py new file mode 100644 index 0000000000..1a6d358cbe --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-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<