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 61f7ad8224c062ac7189e9006c63d33c24f48b0a Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Thu, 12 Nov 2026 04:28:59 -0800 Subject: [PATCH 3/3] Bound phase-sensitive Type A late-mask reassignment at J9 --- .../LOCAL-PINS.json | 24 + .../p104-type-a-j9-late-mask-bound/NOTICE | 3 + .../p104-type-a-j9-late-mask-bound/PROOF.md | 19 + .../PROVENANCE.json | 125 + .../p104-type-a-j9-late-mask-bound/README.md | 23 + .../SOURCES.json | 18 + .../p104-type-a-j9-late-mask-bound/TASK.json | 117 + .../VERIFICATION.md | 12 + .../VERIFY.json | 14 + .../engines/forward.py | 125 + .../engines/r178_price.py | 53 + .../engines/r178_reverse.py | 148 + .../engines/r179_reverse.py | 147 + .../engines/r189_forward.py | 73 + .../engines/r189_reverse.py | 127 + .../engines/r190_forward.py | 87 + .../engines/r190_reverse.py | 141 + .../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/R92-PRICE.json | 2539 +++++++++++++++++ .../inputs/pricing.py | 82 + .../receipts/R178-PRICE.json | 39 + .../receipts/R178-REVERSE.json | 2189 ++++++++++++++ .../receipts/R189-FORWARD.json | 252 ++ .../receipts/R189-REVERSE.json | 389 +++ .../receipts/R190-FORWARD.json | 393 +++ .../receipts/R190-REVERSE.json | 1909 +++++++++++++ .../p104-type-a-j9-late-mask-bound/replay.py | 191 ++ 32 files changed, 9899 insertions(+) create mode 100644 research/p104-type-a-j9-late-mask-bound/LOCAL-PINS.json create mode 100644 research/p104-type-a-j9-late-mask-bound/NOTICE create mode 100644 research/p104-type-a-j9-late-mask-bound/PROOF.md create mode 100644 research/p104-type-a-j9-late-mask-bound/PROVENANCE.json create mode 100644 research/p104-type-a-j9-late-mask-bound/README.md create mode 100644 research/p104-type-a-j9-late-mask-bound/SOURCES.json create mode 100644 research/p104-type-a-j9-late-mask-bound/TASK.json create mode 100644 research/p104-type-a-j9-late-mask-bound/VERIFICATION.md create mode 100644 research/p104-type-a-j9-late-mask-bound/VERIFY.json create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/forward.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r178_price.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r178_reverse.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r179_reverse.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r189_forward.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r189_reverse.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r190_forward.py create mode 100644 research/p104-type-a-j9-late-mask-bound/engines/r190_reverse.py create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/7113-SHA256.json create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/7113-application.py create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/7113-signed-child.py create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/CALLER.json create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/PHYSICAL-BINDING.json create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/PR7362-SHA256.json create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/R92-PRICE.json create mode 100644 research/p104-type-a-j9-late-mask-bound/inputs/pricing.py create mode 100644 research/p104-type-a-j9-late-mask-bound/receipts/R178-PRICE.json create mode 100644 research/p104-type-a-j9-late-mask-bound/receipts/R178-REVERSE.json create mode 100644 research/p104-type-a-j9-late-mask-bound/receipts/R189-FORWARD.json create mode 100644 research/p104-type-a-j9-late-mask-bound/receipts/R189-REVERSE.json create mode 100644 research/p104-type-a-j9-late-mask-bound/receipts/R190-FORWARD.json create mode 100644 research/p104-type-a-j9-late-mask-bound/receipts/R190-REVERSE.json create mode 100644 research/p104-type-a-j9-late-mask-bound/replay.py diff --git a/research/p104-type-a-j9-late-mask-bound/LOCAL-PINS.json b/research/p104-type-a-j9-late-mask-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..495ced65ff --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/LOCAL-PINS.json @@ -0,0 +1,24 @@ +{ + "engines/forward.py": "75d94780f9db49a4b08bb0e7fb4bd7fc04adb8cabbf73d83a809179c04c3d439", + "engines/r178_price.py": "c043f32e438e3ad820ad7afd91f74d5bfc7c7aba95b578efc0b8761ff76cab83", + "engines/r178_reverse.py": "2faedaf76b8d1cc399294f5595862092de75ea1dd3a0ec41898a61edad006d53", + "engines/r179_reverse.py": "720a921b8eb215675bf738c94dac3361592c342fd8f8eeda6d6efb6888061a5a", + "engines/r189_forward.py": "1b393f9c01e50f6a554f9602b0e927598da5797431257fa085d30e310a448b9b", + "engines/r189_reverse.py": "0fa3efbf7f2f9683a16d7303f8fb976320ae7036dafa7321f6dba0576bb8ecee", + "engines/r190_forward.py": "daaef01b07304f568790e58777372984a03b5334eebf5e22472a37fe54867d75", + "engines/r190_reverse.py": "ccb796b8ebe305e7c177854a9c5ad49f35f52de32dbf3190afb5c1315c878dc8", + "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/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/R178-PRICE.json": "fbb1e5f1de9274bba2d0445b3868c50a04b178751c0f9244ebf5229128bc4651", + "receipts/R178-REVERSE.json": "ad9bbc64a9b866a89f48f1fac0b0346c18105c4b69e62aa41a9cd5575e5c5942", + "receipts/R189-FORWARD.json": "5da0116cc6d0a36d1843d512b4a70fd4f0d296d3fef9f949f2635fd9578c1121", + "receipts/R189-REVERSE.json": "2b7a2d4c4a278f97118c20a42eb48f92f1e6a092d10204398f9a1751106b9904", + "receipts/R190-FORWARD.json": "c6fba198edf5900127e8932af70826525d5fb462ca00ec2c7b3ef832d895ce76", + "receipts/R190-REVERSE.json": "beca4b8321f3ac5b7550ef4269d42ed5131c2e1b717c62481db34e890cd7140b" +} diff --git a/research/p104-type-a-j9-late-mask-bound/NOTICE b/research/p104-type-a-j9-late-mask-bound/NOTICE new file mode 100644 index 0000000000..5504001ee1 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/NOTICE @@ -0,0 +1,3 @@ +Apache-2.0. + +#7334 and #7113 supply the native word and signed caller. #7410 supplies the exact predecessor seam, price and signed verification methods. #7412 supplies adjacent fixed-host support methodology. #7362 supplies the signed rank stock and #7298 the directed tariff. OpenAI Codex and subagents materially assisted. diff --git a/research/p104-type-a-j9-late-mask-bound/PROOF.md b/research/p104-type-a-j9-late-mask-bound/PROOF.md new file mode 100644 index 0000000000..9d0f5d06a3 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/PROOF.md @@ -0,0 +1,19 @@ +# Exact phase-sensitive fixed-host obstruction + +## Required host and legitimate specialization + +The #7113 Type A caller has 36 roles and 96 ports. At cut 1741 the first eight body stages and four QUERYs precede the cut. The final nine Type A body stages follow. Their endpoint is diagonal with one common q⁻¹ factor. Permute the late masks and relabel final outputs by the inverse permutation. The original phase and early masks remain attached to their original roots. + +Let X be the permutation matrix that sends input basis vector i to the assigned late role. At a fixed sign and all bodies equal to one, let G be the old prefix before cut 1741 and M the middle up to but excluding J9 at 3058. Write N=MG, B for the old J9 block and S for its suffix. The old endpoint is SBN=q⁻¹I. For the revised endpoint to hold with final X⁻¹ and every other event unchanged, X⁻¹SB'N=q⁻¹I. Both inverses exist, and the only possible new host is B'=BNXN⁻¹. Equivalently, the previously forced cut seam W=GXG⁻¹ gives B'=BMWM⁻¹. This argument grants separate arbitrary rational four-role host actions at q=+1 and q=−1. + +The interval [1741,3058) has 50 Type A ADDs, 16 IDLE_ONEs, two LAMBDAs and three SCALEs. No J or QUERY lies in this Type A interval. The 16 idles involve stages 9–16, so the interval is body-dependent. The exact tests specialize all body variables to one. The retained signed-child matrix has +1 and i on its Walsh sectors. At width two the central +/− signs can be obtained by using two equal central eigenvalues, independently of choosing +1 in the fresh disjoint body axes. The bundled #7113 physical binding and signed child authenticate this specialization. + +## Exact class criterion + +Let H be the old J9 roles {0,9,18,27}, and E its complement. The original host B is invertible and acts only within H. Therefore B'−B is confined to H×H exactly when NXN⁻¹−I is. Untouched exterior rows require NX and N to agree on E rows. Untouched exterior columns require XN⁻¹ and N⁻¹ to agree on E columns. For role i these constraints preserve the column N[E,i] and the row N⁻¹[i,E]. A permutation satisfies the fixed-host support gate at both signs exactly when it stays within the equality classes of those two fingerprints at both signs. + +Independent forward columns and reverse covectors agree on the same 35 classes. Every class is a singleton except {9,27}. Those two roles have identical whole diagonal words, with no early bodies and just late body 9. The explicit 9/27 transposition is checked to have no exterior defect at both unit-body signs. The only alternative permutations within the classes are that equal-mask transposition and the identity. Both leave every productive rank unchanged. Opposite sorting in each class reproduces the original histogram and gives exact directed gross [0,0] before any host cost. The result holds for all admissible κ because the histograms coincide. + +The 0/9 price control has signed productive delta {9:−96, 73:+192, 137:−96} and no new paid calls. Its directed gross upper is below 23.17190378842640 raw at the old crossing upper endpoint. Both signed matrices show exterior support defects. The whole-family result means there is no priced candidate in the fixed host and event model. Verified paid saving and Δκ are zero. + +Different host clocks, enlarged role support, changed caller events, or a new paid schedule remain outside this scope. diff --git a/research/p104-type-a-j9-late-mask-bound/PROVENANCE.json b/research/p104-type-a-j9-late-mask-bound/PROVENANCE.json new file mode 100644 index 0000000000..648f93f44a --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/PROVENANCE.json @@ -0,0 +1,125 @@ +{ + "comparator": { + "author": "Clear1nsight", + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "kappa": "0.00364665195644", + "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": { + "engines/r178_reverse.py": { + "commit": "ae41a5abb02fd18d3e270ee2ab4822b651902d0d", + "git_blob": "f2ee99c8d481ace7f211223dc809e5631b590168", + "path": "research/p104-type-a-late-mask-permutation-bound/engines/seam_reverse.py", + "sha256": "2faedaf76b8d1cc399294f5595862092de75ea1dd3a0ec41898a61edad006d53", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/ae41a5abb02fd18d3e270ee2ab4822b651902d0d/research/p104-type-a-late-mask-permutation-bound/engines/seam_reverse.py" + }, + "engines/r179_reverse.py": { + "commit": "ae41a5abb02fd18d3e270ee2ab4822b651902d0d", + "git_blob": "329f9c2938e84d5f45eee2b50c876bc0c55746bb", + "path": "research/p104-type-a-late-mask-permutation-bound/engines/family_reverse.py", + "sha256": "720a921b8eb215675bf738c94dac3361592c342fd8f8eeda6d6efb6888061a5a", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/ae41a5abb02fd18d3e270ee2ab4822b651902d0d/research/p104-type-a-late-mask-permutation-bound/engines/family_reverse.py" + }, + "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/pricing.py": { + "commit": "c522451caf287bb3c16eaece72be4c263315dca4", + "git_blob": "40ec194017bda1d524bba4f07b188c53281419d0", + "path": "research/adjacent-owned-add-exchange-bound/pricing.py", + "sha256": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/c522451caf287bb3c16eaece72be4c263315dca4/research/adjacent-owned-add-exchange-bound/pricing.py" + }, + "receipts/R178-PRICE.json": { + "commit": "ae41a5abb02fd18d3e270ee2ab4822b651902d0d", + "git_blob": "7fdacc6f447015123b6299be855c050982b98424", + "path": "research/p104-type-a-late-mask-permutation-bound/receipts/R178-PRICE.json", + "sha256": "fbb1e5f1de9274bba2d0445b3868c50a04b178751c0f9244ebf5229128bc4651", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/ae41a5abb02fd18d3e270ee2ab4822b651902d0d/research/p104-type-a-late-mask-permutation-bound/receipts/R178-PRICE.json" + }, + "receipts/R178-REVERSE.json": { + "commit": "ae41a5abb02fd18d3e270ee2ab4822b651902d0d", + "git_blob": "f599f438ef3ff75ac55d2c463c6e0c9c95f6816e", + "path": "research/p104-type-a-late-mask-permutation-bound/receipts/R178-REVERSE.json", + "sha256": "ad9bbc64a9b866a89f48f1fac0b0346c18105c4b69e62aa41a9cd5575e5c5942", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/ae41a5abb02fd18d3e270ee2ab4822b651902d0d/research/p104-type-a-late-mask-permutation-bound/receipts/R178-REVERSE.json" + } + }, + "predecessors": { + "fixed_host_methods": { + "credit": "Adjacent fixed J8/J9 support analysis for different QUERY demotions and endpoint.", + "head": "4dfa0a393fd12101af5ffed161ed1bc5aa045f11", + "pull_request": 7412, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7412" + }, + "fixed_phase_even_seam": { + "credit": "Exact source for signed prefix and seam, directed price, and the excluded fixed phase-even model.", + "head": "ae41a5abb02fd18d3e270ee2ab4822b651902d0d", + "pull_request": 7410, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7410" + }, + "pricing_engine": { + "credit": "Exact directed rational tariff implementation", + "head": "c522451caf287bb3c16eaece72be4c263315dca4", + "url": "https://github.com/CrocSwap/integer-mult-bounds/blob/c522451caf287bb3c16eaece72be4c263315dca4/research/adjacent-owned-add-exchange-bound/pricing.py" + }, + "rank_two_price": { + "credit": "Exact input receipt for the directed comparator price", + "head": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7362" + }, + "signed_caller": { + "credit": "Rohan Arun, literal signed Type A/B caller and physical gate", + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7113" + } + }, + "schema_version": 1 +} diff --git a/research/p104-type-a-j9-late-mask-bound/README.md b/research/p104-type-a-j9-late-mask-bound/README.md new file mode 100644 index 0000000000..0d3c62bb42 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/README.md @@ -0,0 +1,23 @@ +# Phase-sensitive Type A late-mask reassignment at J9 + +**NO VERIFIED GAIN.** The comparator is exact [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) at `aaeec8c0acf01e99a5f331ef363a698d9c084ace` with the signed caller [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) at `07a76c5e2738882c0cb322278e56f6cae3c9885d`. Its independently reproduced κ is 0.00364665195644. + +Can an arbitrary late-mask permutation at Type A cut 1741 be absorbed into the existing paid J9 at clock 3058? Allow phase-sensitive action inside the four original J9 roles (9,0,18,27) and keep the remaining caller word and paid positions fixed. + +The optimistic roots 0/9 swap would change ranks 137 and 9 to 73 and 73 across 96 ports. At q=+1, the forced replacement has 16 coefficients outside the four-role block, including (10,0)=4. At q=−1, it has eight, including (0,10)=−2. Either legal unit-body specialization excludes the swap. + +For the whole fixed-host family, the two signed prefix comparisons force 35 exact role classes. All are singletons except {9,27}. Those two roles have identical full diagonal words, with q⁻¹ and only body 9. Every permutation that can pass the unit-body host support gate preserves the exact productive histogram. The whole-family optimistic gross is [0,0]. No permutation search was required and no key remains unresolved in scope. + +From a clean checkout use POSIX CPython 3.12 with assertions. + +```sh +python3.12 -I -B research/p104-type-a-j9-late-mask-bound/replay.py +``` + +The Git-free command authenticates the pinned caller and exact predecessors, verifies the signed physical specializations, regenerates six deterministic receipts, and rejects a changed source receipt. Use `--out fresh-directory` to keep the regenerated outputs. See [proof and price](PROOF.md) and [verification](VERIFICATION.md). + +[#7410](https://github.com/CrocSwap/integer-mult-bounds/pull/7410) at `ae41a5abb02fd18d3e270ee2ab4822b651902d0d` supplies the original late-mask setup, price, and signed prefix evidence. Its separate gate concerns a fixed phase-even seam at cut 1741. [#7412](https://github.com/CrocSwap/integer-mult-bounds/pull/7412) at `4dfa0a393fd12101af5ffed161ed1bc5aa045f11` supplies related fixed-host support methods for QUERY demotion. #7334 and #7113 supply the exact native word and caller, #7362 the signed rank stock, and #7298 the directed tariff. OpenAI Codex and subagents materially assisted. Apache-2.0. + +## Open next questions + +A different host clock, more exposed host roles or another paid schedule remains open. Start by pinning and pricing one exact alternative. Recompute its exterior fingerprints before trying all-body identities or a native implementation. diff --git a/research/p104-type-a-j9-late-mask-bound/SOURCES.json b/research/p104-type-a-j9-late-mask-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "path": "certificates/selected-result.json", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "usage": "provenance" + }, + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/p104-type-a-j9-late-mask-bound/TASK.json b/research/p104-type-a-j9-late-mask-bound/TASK.json new file mode 100644 index 0000000000..66637da3df --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113. All permutations of 36 Type A late masks at cut 1741 whose unique unit-body seams can be absorbed by the already-paid J9 at clock 3058 on its four original roles, allowing signed phase-sensitive host changes.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 Type A fixed J9 late-mask research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "Balanced productive ranks can strictly improve the signed moment only if the reassignment preserves the full paid caller and exact arbitrary-input action.", + "budget_minutes": 12, + "evidence": "The 0/9 control fails both signed exterior tests. The full family has 35 compatibility classes and the only nonsingleton class {9,27} contains identical masks. Exact gross [0,0], zero unresolved.", + "open_questions": [ + { + "blocked_by": "The fixed J9 host at 3058 has only one compatible nonsingleton class, whose two roots have identical masks.", + "first_step": "Pin a distinct priced host interface and compare the two exterior signed fingerprints before any full-body decoding.", + "question": "Can a different host clock or larger role interface realize a profitable late-mask reassignment on the exact word?", + "why_it_matters": "The largest unpriced reassignment preserves all old paid positions while increasing the productive rank 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": "Allow a phase-sensitive implementation at the existing J9 instead of a phase-even seam at the mask cut.", + "scope_status": "changed", + "stop_rule": "One exact roots 0/9 case, then 36 roles, two unit-body signs, 20 seconds per engine. Stop if the entire compatibility quotient has zero gross. No permutation enumeration before price.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-type-a-j9-late-mask-bound/VERIFICATION.md b/research/p104-type-a-j9-late-mask-bound/VERIFICATION.md new file mode 100644 index 0000000000..54492e04eb --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/VERIFICATION.md @@ -0,0 +1,12 @@ +# Verification + +POSIX CPython 3.12.14 and assertions. The two R189 support engines took 0.39s and 0.12s. The two R190 class engines took 0.56s and 0.25s. Each was capped at 20 seconds and exited 0. The forward and reverse methods both cover all 36 input coordinates at each sign, and the class criterion exhausts the fixed domain before permutation search. + +The offline package regenerates the R178 directed price and signed seam, both R189 support receipts, and both R190 fingerprint receipts. It checks the exact 0/9 exterior witnesses, validates the legal physical signed phases, compares the exact classes and projected histogram, and checks that the equal-mask 9/27 transposition stays within J9 at both signs. The controls also recover the old host from the identity seam and reject a corrupted predecessor receipt and an artificial exterior defect. + +Nontrivial bodies and q=±i are untested for the remaining equal-mask symmetry. There is no gain to construct, so a replacement supplier, its native replay, and full compiler, tape, precision and recurrence checks were skipped. They are separate gates for future changes outside the fixed domain. + +A first package-wrapper run used one excess zero in the literal Type A +diagonal shape assertion. The corrected assertion compares the two +full rows and checks the nonzero body index directly. Scientific +receipts were unchanged. diff --git a/research/p104-type-a-j9-late-mask-bound/VERIFY.json b/research/p104-type-a-j9-late-mask-bound/VERIFY.json new file mode 100644 index 0000000000..a210897674 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Replay two predecessor receipts, both exact fixed-J9 support checks and both whole-family compatibility partitions. Verify legal physical signed phases and controls.", + "timeout_seconds": 120 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-type-a-j9-late-mask-bound/engines/forward.py b/research/p104-type-a-j9-late-mask-bound/engines/forward.py new file mode 100644 index 0000000000..7842fd300e --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/engines/forward.py @@ -0,0 +1,125 @@ +"""Check profitable Type A late-mask swaps by direct forward propagation.""" +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from itertools import combinations +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +HERE = Path(__file__).resolve().parent +N = 36 +CUT = 1741 +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} + + +def unit(i): + return [Fraction(i == j) for j in range(N)] + + +def apply(events, column, q, inverse=False): + col = column.copy() + direction = -1 if inverse else 1 + for event in reversed(events) if inverse else events: + if event[0] == "B": + continue + if event[0] == "J": + _, _, (u, v, x, y), _ = event + assert len({u, v, x, y}) == 4 + col[v] += direction * q * col[u] + col[x] -= direction * q * col[y] + continue + assert event[0] == "A" + _, op, dest, *args = event + if op == "ADD": + src, value = args + col[dest] += direction * Fraction(value) * col[src] + elif op == "QUERY": + src, exponent = args + assert exponent == -1 + col[dest] += direction * q * col[src] + elif op == "SWAP": + src, = args + col[dest], col[src] = col[src], col[dest] + elif op == "SCALE": + value, = args + col[dest] *= Fraction(value) ** direction + else: + assert op in ("IDLE_ONE", "LAMBDA") + return col + + +def stop(*_): + raise TimeoutError("30-second solver cap") + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(30) + for name, digest in PINS.items(): + assert sha256((HERE / name).read_bytes()).hexdigest() == digest + caller = loads((HERE / "inputs/CALLER.json").read_bytes()) + old = loads((HERE / "inputs/R92-PRICE.json").read_bytes()) + tape = caller["events"] + a = caller["types"]["A"] + assert len(a["ports"]) == 96 and a["roles"] == N and len(tape) == 4783 + assert tape[CUT] == ["A", "ADD", 10, 0, "2"] + assert all(row[:2] == [-1, 0] for row in a["diagonal"]) + counts = [(sum(row[2:10]), sum(row[10:])) for row in a["diagonal"]] + pre = tape[:CUT] + forward, inverse = {}, {} + for q in (1, -1): + forward[q] = [apply(pre, unit(i), q) for i in range(N)] + inverse[q] = [apply(pre, unit(i), q, inverse=True) for i in range(N)] + for i in range(N): + assert apply(pre, inverse[q][i], q) == unit(i) + assert apply(tape, unit(i), q) == [q * entry for entry in unit(i)] + cases = [] + ranks = Counter() + for a, b in combinations(range(N), 2): + x, y = counts[a] + u, v = counts[b] + before = sorted((1 + 8*(x+y), 1 + 8*(u+v))) + after = sorted((1 + 8*(x+v), 1 + 8*(u+y))) + assert sum(before) == sum(after) + if after[0] <= before[0]: + status = "tie" if after == before else "worse" + ranks[status] += 1 + cases.append([a, b, before, after, status, None]) + continue + ranks["profitable"] += 1 + vectors = {q: [x-y for x,y in zip(forward[q][a], forward[q][b], strict=True)] + for q in (1, -1)} + duals = {q: [col[a]-col[b] for col in inverse[q]] for q in (1, -1)} + for q in (1, -1): + assert sum(x*y for x,y in zip(vectors[q], duals[q], strict=True)) == 2 + # W - I = -(G d)(d^T G^-1), where d = e_a - e_b. + witness = None + for i, j in ((i, j) for i in range(N) for j in range(N)): + odd = vectors[-1][i]*duals[-1][j] - vectors[1][i]*duals[1][j] + if odd: + witness = [i, j, str(odd)] + break + status = "excluded" if witness else "survives" + cases.append([a, b, before, after, status, witness]) + ranks[status] += 1 + assert len(cases) == 630 + assert next(case for case in cases if case[:2] == [0, 9])[-1] == [0, 0, "4"] + neutral_plus = apply(pre, unit(0), 1) + assert neutral_plus == forward[1][0] + cost = run_path(str(HERE / "inputs/pricing.py"))["cost"] + quote = cost(Counter({73: 192, 137: -96, 9: -96}), Fraction(old["old_crossing_upper"])) + alarm(0) + print(dumps({"pins": PINS, "head": old["head"], "cut": CUT, + "counts": ranks, "budget_seconds": 30, "cases": cases, + "control_pair_0_9_upper": str(quote[1])}, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-type-a-j9-late-mask-bound/engines/r178_price.py b/research/p104-type-a-j9-late-mask-bound/engines/r178_price.py new file mode 100644 index 0000000000..ac7534608b --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/engines/r178_price.py @@ -0,0 +1,53 @@ +"""Price one Type A late-mask transposition and its whole permutation ceiling.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps,loads +from pathlib import Path +from runpy import run_path + +ROOT=Path(__file__).resolve().parent +PINS={"CALLER.json":"255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "R92-PRICE.json":"05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "pricing.py":"f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182"} + + +def main(): + assert __debug__ + raw={} + for name,h in PINS.items(): + b=(ROOT/"inputs"/name).read_bytes() + assert sha256(b).hexdigest()==h + raw[name]=b + c=loads(raw["CALLER.json"]) + base=loads(raw["R92-PRICE.json"]) + a=c["types"]["A"] + assert len(a["ports"])==96 and a["roles"]==36 + counts=[(sum(r[2:10]),sum(r[10:])) for r in a["diagonal"]] + assert all(r[:2]==[-1,0] for r in a["diagonal"]) + old=[1+8*(x+y) for x,y in counts] + pair=(0,9) + i,j=pair + after=[1+8*(counts[i][0]+counts[j][1]),1+8*(counts[j][0]+counts[i][1])] + assert [old[i],old[j],*after]==[137,9,73,73] + best=[1+8*(x+y) for x,y in zip(sorted(x for x,_ in counts),sorted((y for _,y in counts),reverse=True),strict=True)] + k=Q(base["old_crossing_upper"]) + cost=run_path(str(ROOT/"inputs/pricing.py"))["cost"] + whole=Counter({d:96*n for d,n in Counter(best).items()}) + whole.subtract({d:96*n for d,n in Counter(old).items()}) + delta=Counter({73:192,137:-96,9:-96}) + 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()}) + stock.update(delta) + gross=cost(delta,k) + assert sum(r*n for r,n in delta.items())==sum(r*n for r,n in whole.items())==0 + assert 00 + tape=c["events"] + assert len(tape)==4783 and tape[J9][:3]==["J",9,list(HOST)] + assert [x[1] for x in tape[:CUT] if x[0]=="J"]==list(range(1,9)) + masks=[x[3] for x in tape[CUT:J9] if x[:2]==["A","IDLE_ONE"]] + assert len(masks)==16 and all(9 in m and all(i>=9 for i in m) for m in masks) + assert not any(x[0]=="J" or x[:2]==["A","QUERY"] for x in tape[CUT:J9]) + e=unit(ROOTS[0]) + e[ROOTS[1]]=-1 + output=[] + for q in (1,-1): + n_e=apply(tape[:J9],e,q) + transported=apply(tape[CUT:J9],apply(tape[:CUT],e,q),q) + assert transported==n_e + out=apply(tape[J9:J9+1],n_e,q) + dual=[] + for i in range(36): + u=unit(i) + inv=apply(tape[:J9],u,q,inverse=True) + assert apply(tape[:J9],inv,q)==u + assert apply(tape,u,q)==[q*a for a in u] + dual.append(inv[ROOTS[0]]-inv[ROOTS[1]]) + assert sum(a*b for a,b in zip(n_e,dual,strict=True))==2 + defect=[(i,j,-a*b) for i,a in enumerate(out) for j,b in enumerate(dual) if a and b] + outside=[x for x in defect if x[0] not in HOST or x[1] not in HOST] + output.append({"phase":q,"defect_nonzeros":len(defect), + "outside_nonzeros":len(outside),"first_outside":outside[:12]}) + alarm(0) + print(dumps({"pins":PINS|f["PINS"],"head":price["head"],"caller":price["caller"], + "cut":CUT,"host_clock":J9,"host_roles":HOST,"root_pair":ROOTS, + "basis_columns":36,"runner_cap_seconds":20,"unit_middle_masks":masks, + "price_gross":price["gross"],"signs":output, + "excluded":any(s["outside_nonzeros"] for s in output)}, + default=str,indent=2,sort_keys=True)) + + +if __name__=="__main__": + main() diff --git a/research/p104-type-a-j9-late-mask-bound/engines/r189_reverse.py b/research/p104-type-a-j9-late-mask-bound/engines/r189_reverse.py new file mode 100644 index 0000000000..4b958abb75 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/engines/r189_reverse.py @@ -0,0 +1,127 @@ +"""Check exact unit-body support of the forced J9 replacement.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/R178-REVERSE.json": "ad9bbc64a9b866a89f48f1fac0b0346c18105c4b69e62aa41a9cd5575e5c5942", + "inputs/R178-PRICE.json": "fbb1e5f1de9274bba2d0445b3868c50a04b178751c0f9244ebf5229128bc4651", + "inputs/r179.py": "720a921b8eb215675bf738c94dac3361592c342fd8f8eeda6d6efb6888061a5a", +} +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +N, CUT, HOST, SECONDS = 36, 1741, 3058, 20 +ROLES, ROOTS = (9,0,18,27), (0,9) + + +def unique(items): + data = dict(items) + assert len(items) == len(data), "duplicate key" + return data + + +def read(path): + raw = (ROOT / path).read_bytes() + assert sha256(raw).hexdigest() == PINS[path], path + return raw + + +def stop(*_): + raise TimeoutError("20-second exact support cap") + + +def middle(events, ident): + m, counts, idles = ident(), Counter(), [] + for i, (kind, *args) in enumerate(events, CUT): + if kind == "B": + continue + assert kind == "A" + op, d, *params = args + counts[op] += 1 + if op == "ADD": + src, scalar = params + m[d] = [x+Q(scalar)*y for x,y in zip(m[d],m[src],strict=True)] + elif op == "SCALE": + m[d] = [Q(params[0])*x for x in m[d]] + elif op == "SWAP": + src, = params + m[d],m[src] = m[src],m[d] + elif op == "LAMBDA": + assert params[0] in (1,-1) + else: + assert op == "IDLE_ONE" and params[0] and min(params[0]) >= 9 + idles.append([i,d,params[0]]) + return m, counts, idles + + +def exterior(a,b): + return [[i,j,a[i][j]-b[i][j]] for i in range(N) for j in range(N) + if (i not in ROLES or j not in ROLES) and a[i][j] != b[i][j]] + + +def inputs(): + c,g,p = [loads(read(name),object_pairs_hook=unique) for name in + ("inputs/CALLER.json","inputs/R178-REVERSE.json","inputs/R178-PRICE.json")] + assert (g["benchmark"],g["caller"],g["cut"],g["roots"]) == (HEAD,CALLER,CUT,list(ROOTS)) + assert (p["head"],p["caller"],p["cut"],p["pair"]) == (HEAD,CALLER,CUT,list(ROOTS)) + assert p["added_paid"] == 0 and p["signed_delta"] == {"9":-96,"73":192,"137":-96} + assert Q(p["complete_probe"][0]) > 0 + assert g["central_signs"] == [1,-1] and g["basis_columns"] == N + tape = c["events"] + assert len(tape) == 4783 and tape[HOST][:3] == ["J",9,list(ROLES)] + assert tape[CUT] == ["A","ADD",10,0,"2"] and c["types"]["A"]["roles"] == N + assert len(c["types"]["A"]["ports"]) == 96 + read("inputs/r179.py") + return c,g,p,run_path(str(ROOT/"inputs/r179.py")) + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(SECONDS) + c,g,p,engine = inputs() + ident, mul, solve, expand = (engine[k] for k in ("identity","product","solve","expand")) + m,counts,idles = middle(c["events"][CUT:HOST],ident) + assert [x[0] for x in idles] == list(range(1742,1788,3)) and counts["LAMBDA"] == 2 + im = solve(m,ident()) + assert mul(m,im) == mul(im,m) == ident() + cases = [] + for q,label in ((1,"plus"),(-1,"minus")): + gp = expand(g["prefix_"+label]) + ig = solve(gp,ident()) + assert mul(gp,ig) == mul(ig,gp) == ident() + a,b = ROOTS + gx = [row.copy() for row in gp] + for row in gx: + row[a],row[b] = row[b],row[a] + w = mul(gx,ig) + assert w == expand(g["seam_"+label]) and mul(w,gp) == gx + old = ident() + u,v,x,y = ROLES + old[v][u],old[x][y] = Q(q),Q(-q) + bm = mul(old,m) + need = mul(mul(bm,w),im) + assert mul(need,m) == mul(bm,w) and mul(bm,im) == old + wrong = [row.copy() for row in old] + wrong[1][1] += 1 + assert exterior(wrong,old) == [[1,1,Q(1)]] + outside = exterior(need,old) + cases.append({"q":q,"outside_nonzeros":len(outside),"outside":outside, + "first_outside":outside[0] if outside else None}) + alarm(0) + print(dumps({"head":HEAD,"caller":CALLER,"pins":PINS,"cut":CUT,"host":HOST, + "host_roles":ROLES,"roots":ROOTS,"basis_columns":N,"runner_cap_seconds":SECONDS, + "middle_a_counts":counts,"middle_idles":idles,"price":p,"cases":cases, + "status":"excluded by exact support" if any(r["outside"] for r in cases) else "survives unit signs", + "controls":["identity seam gives old host","outside mutation rejected", + "exact signed seam reconstructs R178"]},sort_keys=True,indent=2,default=str)) + + +if __name__=="__main__": + main() diff --git a/research/p104-type-a-j9-late-mask-bound/engines/r190_forward.py b/research/p104-type-a-j9-late-mask-bound/engines/r190_forward.py new file mode 100644 index 0000000000..a548916233 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/engines/r190_forward.py @@ -0,0 +1,87 @@ +"""Enumerate exact fixed-host compatibility classes for the late-mask seam.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT=Path(__file__).resolve().parent +CUT,HOST_CLOCK,N=1741,3058,36 +HOST={0,9,18,27} +PIN="75d94780f9db49a4b08bb0e7fb4bd7fc04adb8cabbf73d83a809179c04c3d439" + + +def stop(*_): + raise TimeoutError("20-second fixed-host compatibility screen") + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(20) + path=ROOT/"forward.py" + assert sha256(path.read_bytes()).hexdigest()==PIN + f=run_path(str(path)) + for name,digest in f["PINS"].items(): + assert sha256((ROOT/name).read_bytes()).hexdigest()==digest + caller=loads((ROOT/"inputs/CALLER.json").read_bytes()) + base=loads((ROOT/"inputs/R92-PRICE.json").read_bytes()) + tape=caller["events"] + assert len(tape)==4783 and tape[CUT]==["A","ADD",10,0,"2"] + assert tape[HOST_CLOCK][:3]==["J",9,[9,0,18,27]] + early=set(range(1,9)) + late=set(range(9,18)) + for part,stages in ((tape[:CUT],early),(tape[CUT:],late)): + assert {e[1] for e in part if e[0]=="J"}==stages + assert all(set(e[3]) <= stages for e in part if e[:2]==["A","IDLE_ONE"]) + ports=caller["types"]["A"]["ports"] + diagonals=caller["types"]["A"]["diagonal"] + assert len(ports)==96 and len(diagonals)==N and all(r[:2]==[-1,0] for r in diagonals) + counts=[(sum(d[2:10]),sum(d[10:])) for d in diagonals] + outside=[r for r in range(N) if r not in HOST] + unit,apply=f["unit"],f["apply"] + signatures=[[] for _ in range(N)] + for q in (1,-1): + pre=tape[:HOST_CLOCK] + columns=[apply(pre,unit(i),q) for i in range(N)] + inv=[apply(pre,unit(i),q,inverse=True) for i in range(N)] + assert all(apply(pre,v,q)==unit(i) for i,v in enumerate(inv)) + for i in range(N): + signatures[i].extend(columns[i][j] for j in outside) + signatures[i].extend(inv[j][i] for j in outside) + classes={} + for i,signature in enumerate(signatures): + classes.setdefault(tuple(signature),[]).append(i) + groups=list(classes.values()) + assert sum(map(len,groups))==N + assert signatures[0]!=signatures[9] + old=[1+8*(e+l) for e,l in counts] + best=list(range(N)) + for group in groups: + low_early=sorted(group,key=lambda j:(counts[j][0],j)) + high_late=sorted(group,key=lambda j:(-counts[j][1],j)) + for i,j in zip(low_early,high_late,strict=True): + best[i]=j + assert sorted(best)==list(range(N)) and all(signatures[i]==signatures[j] for i,j in enumerate(best)) + new=[1+8*(counts[i][0]+counts[j][1]) for i,j in enumerate(best)] + delta=Counter(new) + delta.subtract(old) + delta=Counter({r:96*d for r,d in delta.items() if d}) + assert sum(r*n for r,n in delta.items())==0 + cost=run_path(str(ROOT/"inputs/pricing.py"))["cost"] + upper=cost(delta,Q(base["old_crossing_upper"])) if delta else (Q(0),Q(0)) + alarm(0) + print(dumps({"pins":f["PINS"]|{"forward.py":PIN},"head":base["head"],"caller":base["caller_head"], + "cut":CUT,"host":HOST_CLOCK,"host_roles":sorted(HOST),"signs":[1,-1], + "role_cap":N,"runner_cap_seconds":20,"classes":groups, + "class_counts":[[counts[j] for j in group] for group in groups], + "assignment_examined":best,"productive_delta":delta,"gross_upper":upper, + "tested_permutations":0, + "unresolved_within_scope":0 if not delta else None}, + default=str,indent=2,sort_keys=True)) + + +if __name__=="__main__": + main() diff --git a/research/p104-type-a-j9-late-mask-bound/engines/r190_reverse.py b/research/p104-type-a-j9-late-mask-bound/engines/r190_reverse.py new file mode 100644 index 0000000000..a998f087c9 --- /dev/null +++ b/research/p104-type-a-j9-late-mask-bound/engines/r190_reverse.py @@ -0,0 +1,141 @@ +"""Exact compatibility classes for all Type A masks at the retained J9.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/R189.json": "2b7a2d4c4a278f97118c20a42eb48f92f1e6a092d10204398f9a1751106b9904", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "inputs/r178.py": "2faedaf76b8d1cc399294f5595862092de75ea1dd3a0ec41898a61edad006d53", + "inputs/r179.py": "720a921b8eb215675bf738c94dac3361592c342fd8f8eeda6d6efb6888061a5a", +} +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +N, CUT, HOST, PORTS, SECONDS = 36,1741,3058,96,20 +ROLES = (9,0,18,27) +EXT = tuple(i for i in range(N) if i not in ROLES) + + +def unique(items): + result = dict(items) + assert len(items) == len(result), "duplicate key" + return result + + +def read(path): + raw = (ROOT / path).read_bytes() + assert sha256(raw).hexdigest() == PINS[path], path + return raw + + +def engine(path): + read(path) + return run_path(str(ROOT / path)) + + +def stop(*_): + raise TimeoutError("20-second fingerprint cap") + + +def sparse(matrix): + return [[i,j,v] for i,row in enumerate(matrix) for j,v in enumerate(row) if v] + + +def fingerprints(n,i): + return [tuple(n[j][r] for j in EXT)+tuple(i[r][j] for j in EXT) for r in range(N)] + + +def classes(keys): + partition = {} + for role,key in enumerate(keys): + partition.setdefault(key,[]).append(role) + return list(partition.values()) + + +def histogram(early,late,perm): + return Counter(1+8*(early[i]+late[perm[i]]) for i in range(N)) + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(SECONDS) + c, old, base = [loads(read(path),object_pairs_hook=unique) for path in + ("inputs/CALLER.json","inputs/R189.json","inputs/R92-PRICE.json")] + assert (old["head"],old["caller"],old["cut"],old["host"]) == (HEAD,CALLER,CUT,HOST) + assert (base["head"],base["caller_head"]) == (HEAD,CALLER) + tape = c["events"] + assert len(tape) == 4783 and tape[HOST][:3] == ["J",9,list(ROLES)] + for start,end,stages in ((0,CUT,set(range(1,9))), (CUT,len(tape),set(range(9,18)))): + assert {e[1] for e in tape[start:end] if e[0]=="J"} == stages + assert all(set(e[3]) <= stages for e in tape[start:end] if e[:2]==["A","IDLE_ONE"]) + ops = engine("inputs/r178.py") + algebra = engine("inputs/r179.py") + price = engine("inputs/pricing.py")["cost"] + ident,mul = algebra["identity"],algebra["product"] + vec,cv = ops["basis"],ops["covector"] + signs, certs, matrices = [], [], [] + for q, prior in zip((1,-1),old["cases"],strict=True): + n = [cv(tape[:HOST],vec(r),q) for r in range(N)] + ni = [cv(tape[:HOST],vec(r),q,invert=True) for r in range(N)] + assert mul(n,ni) == mul(ni,n) == ident() + labels = fingerprints(n,ni) + signs.append(labels) + matrices.append((n,ni)) + b = ident() + u,v,x,y = ROLES + b[v][u],b[x][y] = Q(q),Q(-q) + perm = list(range(N)) + perm[0],perm[9] = 9,0 + moved = [[row[j] for j in perm] for row in n] + required = mul(b,mul(moved,ni)) + outside = [[i,j,str(required[i][j]-b[i][j])] for i in range(N) for j in range(N) + if (i in EXT or j in EXT) and required[i][j]!=b[i][j]] + assert outside == prior["outside"] and labels[0] != labels[9] + certs.append({"q":q,"per_sign_classes":classes(labels),"n":sparse(n),"n_inverse":sparse(ni), + "r189_outside_count":len(outside),"r189_first_outside":outside[0]}) + groups = classes(list(zip(*signs,strict=True))) + diagonal = c["types"]["A"]["diagonal"] + assert len(diagonal) == N and len(c["types"]["A"]["ports"]) == PORTS + early = [sum(row[2:10]) for row in diagonal] + late = [sum(row[10:]) for row in diagonal] + optimum = [-1]*N + for group in groups: + e = sorted(group,key=lambda i:(early[i],i)) + l = sorted(group,key=lambda i:(-late[i],i)) + for i,j in zip(e,l,strict=True): + optimum[i] = j + assert sorted(optimum) == list(range(N)) + for n,ni in matrices: + nr = [[row[j] for j in optimum] for row in n] + moved = mul(nr,ni) + assert all(moved[i][j] == (i==j) for i in range(N) for j in range(N) if i in EXT or j in EXT) + old_hist = histogram(early,late,range(N)) + best_hist = histogram(early,late,optimum) + delta = {r:PORTS*(best_hist[r]-old_hist[r]) for r in sorted(old_hist.keys()|best_hist.keys()) + if best_hist[r]!=old_hist[r]} + assert sum(delta.values()) == sum(r*n for r,n in delta.items()) == 0 + interval = price(delta,Q(base["old_crossing_upper"])) + fixed_counts = all(len({early[i] for i in g})==1 or len({late[i] for i in g})==1 for g in groups) + if fixed_counts: + assert not delta and interval == (0,0) + alarm(0) + print(dumps({"head":HEAD,"caller":CALLER,"pins":PINS,"cut":CUT,"host":HOST,"roles":ROLES, + "role_cap":N,"runner_cap_seconds":SECONDS,"ports":PORTS,"phases":certs, + "classes":[{"roles":g,"early_late":[[early[i],late[i]] for i in g]} for g in groups], + "all_classes_freeze_one_count":fixed_counts,"optimum":optimum, + "old_histogram":old_hist,"maximum_histogram":best_hist,"delta":delta, + "signed_gain_interval":interval,"enumerated_permutations":0, + "status":"uniform zero optimistic gain" if not delta else "nonzero class price, stronger gate required"}, + sort_keys=True,indent=2,default=str)) + + +if __name__=="__main__": + main() diff --git a/research/p104-type-a-j9-late-mask-bound/inputs/7113-SHA256.json b/research/p104-type-a-j9-late-mask-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-type-a-j9-late-mask-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-type-a-j9-late-mask-bound/inputs/7113-application.py b/research/p104-type-a-j9-late-mask-bound/inputs/7113-application.py new file mode 100644 index 0000000000..1a6d358cbe --- /dev/null +++ b/research/p104-type-a-j9-late-mask-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<1] == [[9,27]] + assert sorted(i for g in f["classes"] for i in g) == list(range(N)) + assert f["assignment_examined"] == r["optimum"] + assert f["productive_delta"] == r["delta"] == {} + assert f["gross_upper"] == r["signed_gain_interval"] == ["0","0"] + assert f["tested_permutations"] == r["enumerated_permutations"] == 0 + assert r["old_histogram"] == r["maximum_histogram"] and f["unresolved_within_scope"] == 0 + diagonal = decode(source("inputs/CALLER.json"))["types"]["A"]["diagonal"] + assert diagonal[9] == diagonal[27] and diagonal[9][:2] == [-1,0] + assert [stage for stage,flag in enumerate(diagonal[9][2:],1) if flag] == [9] + verify_equal_mask_control(r["phases"]) + + copy("inputs/R178-REVERSE.json",results["R178-REVERSE.json"]+b" ") + try: + launch("r189_reverse.py") + except CalledProcessError as exc: + assert exc.returncode==1 and b"inputs/R178-REVERSE.json" in exc.stderr + else: + raise AssertionError("corrupted predecessor accepted") + if output is not None: + output.mkdir(parents=True) + for name,raw in results.items(): + (output/name).write_bytes(raw) + print("PASS_P104_J9_LATE_MASK_BOUND roles=36 classes=35 nontrivial_equal_masks=1 gross=0 unresolved=0") + + +def main(): + assert __debug__ and sys.version_info[:2] == (3,12) + cli = ArgumentParser(description=__doc__) + cli.add_argument("--out",type=Path) + args = cli.parse_args() + with TemporaryDirectory() as tmp: + replay(Path(tmp),args.out) + + +if __name__=="__main__": + main()