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). 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") diff --git a/research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json b/research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..87e40c3f47 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/LOCAL-PINS.json @@ -0,0 +1,17 @@ +{ + "PROVENANCE.json": "fca52d8864312b65f12f0eee2f062dbebc12dc9d18050df8b29e98a05712e43a", + "engines/host_forward.py": "3f22de2c9f9e53e194b9244df4d3562f0c3f1199b63b91f76e8d3732bb818e99", + "engines/host_reverse.py": "ca5cb7a13b5bffebc7213e677252845edb1a1019e9ad3ee187a3eb6c57569fd9", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "inputs/PR7362-SHA256.json": "2c90ca39b0f075cc4b3ec9e90c66fde473465e7bb50cf1db9a820d3a29556c0b", + "inputs/PR7404-RESULT.json": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/R174-FORWARD.json": "e870a1c386581b11dd2231b657b7e0dc5e3c67eafb51bc7650f853bf22581fd1", + "receipts/R174-PRICE.json": "eb5ba68fe579cfea3ae1c79782850f173bc6e06fb853ce152bf58d7d6ed507b1", + "receipts/R174-REVERSE.json": "686d9ff864fb1305d66a953db99cce3a0ce7dbf1adfaf338c4072a84e638545f" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/NOTICE b/research/p104-retimed-type-a-stage8-host-bound/NOTICE new file mode 100644 index 0000000000..1d19be7778 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/NOTICE @@ -0,0 +1,3 @@ +Apache-2.0 contribution. The exact #7404 result is attributed to Clear1nsight. +See README.md and PROVENANCE.json for predecessor sources and original credit. +OpenAI Codex and subagents materially assisted the proof and independent replay. diff --git a/research/p104-retimed-type-a-stage8-host-bound/PROOF.md b/research/p104-retimed-type-a-stage8-host-bound/PROOF.md new file mode 100644 index 0000000000..aa518579c8 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/PROOF.md @@ -0,0 +1,76 @@ +# A fixed four-field host cannot realize the requested retimed action + +## Scope + +Keep the first Type A port on exact #7334 and #7113. The pinned #7404 +retiming hoists 14 paid idles and cancels 28 scalar ADDs around the +stage-8 J at zero-based clock 1423. Its physical host roles are +(8,0,18,26), bound to native labels (0,112,772,882). +Demote the two QUERYs at 1580 and 1659 to unit ADDs. +The requested productive endpoint removes the central q factor +from roles 0 and 18 and retains every other target. + +On the compared phase and body sectors, grant an arbitrary replacement +host of the form $C+WKV$. The feedthrough $C$ and linear output and +input adapters $W,V$ are independent of the stage-8 body and have +the same normalized action at both central signs. The input and +output host interfaces each have dimension four on those sectors. +The other events remain the exact retimed and demoted skeleton. + +## Required matrices + +Let $P$ and $S$ denote the retimed prefix and demoted suffix, and +$T$ the requested whole endpoint. All three are read at each +specialization. The only possible replacement host is +$S^{-1}TP^{-1}$. Forward matrices check both inverse maps and +the complete reconstructed endpoint. Reverse covectors give +a separate exact computation of the required rows. + +At $q=+1$, the required host is exactly the old J8 for both +$B_8=+1$ and $B_8=-1$, with all other bodies set to one. Their +difference is supported on the old four-role block and its +determinant there is 16. For the granted factorization the +same difference is $W(K_- - K_+)V$. Its column space is contained +in that of $W$ and its row space in that of $V$. Rank four +forces both these spaces to be precisely the old four-role +coordinate spaces. At unit bodies the central sign difference +must then be supported in the same block, since $C,W,V$ are +unchanged across those signs. + +The exact comparison of $q=-1$ and $q=+1$ at unit bodies gives +320 nonzero entries outside the block. In particular, entry +(8,1) equals −2. This violates the necessary support condition +for the tested root pair. + +## Physical signs + +The exact #7113 binding separates the central direction from +the eight fresh stage-8 axes, zero-based axes 65 through 72. +At column multiplicity at least two, the binary gate $C_0$ acts +on each replicated axis with Walsh eigenvalues 1 and $i$, +certified on the integer vectors $(1,1)$ and $(1,-1)$. +Choose all plus Walsh vectors for a positive response. Choose +two minus vectors in the central tensor axis for $q=-1$, or +two minus vectors in the stage-8 body for $B_8=-1$. +The selected factors multiply to $i^2=-1$ and every other +factor remains one. The central direction and all stage +blocks are disjoint. This supplies the three physical sectors +used by the matrix obstruction, with arbitrary linear role +coefficients on each sector. + +## Price and residual scope + +Before charging any new work, one port removes two rank-one paid +QUERYs and lowers two productive ranks from 137 to 136. +The exact directed gross upper is 0.04270044187346692 raw at the +old crossing. The inherited probe has a complete lower margin +above 0.04231287836140672 in that optimistic model. A 96-port +relaxation has gross upper 4.099242419852824 and does not establish +compatibility at any additional port. An extra rank-one paid +field cannot fit the one-port saving. + +The exact four-role gate fails. No edited native host, restoration, +compiler, rounding or full new caller application was needed. +A changed feedthrough or adapter across the compared sectors, +more ingress or egress fields, another root pair or a different +retiming requires separate evidence. diff --git a/research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json b/research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json new file mode 100644 index 0000000000..544abf6bb3 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/PROVENANCE.json @@ -0,0 +1,99 @@ +{ + "comparator": { + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "pull_request": 7334, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334", + "status": "strongest independently reproduced complete comparable witness" + }, + "derived_inputs": { + "inputs/R92-PRICE.json": { + "key": "R92-PRICE.json", + "receipt": "inputs/PR7362-SHA256.json" + } + }, + "files": { + "inputs/7113-SHA256.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "5a7d6b80dc51aa918a5d521b60d18f9a6bbbc52e", + "path": "research/signed-caller-8x9/SHA256.json", + "sha256": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "source": "https://github.com/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/SHA256.json" + }, + "inputs/7113-application.py": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "1a6d358cbec88e70615e5314cdfca9e123124f83", + "path": "research/signed-caller-8x9/replay/supplier7112/short-caller/upstream_application.py", + "sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "source": "https://github.com/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/replay/supplier7112/short-caller/upstream_application.py" + }, + "inputs/7113-signed-child.py": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "0980a6559ba1939763de5c798c7947c8bdd51d67", + "path": "research/signed-caller-8x9/replay/supplier7112/short-caller/signed_child.py", + "sha256": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "source": "https://github.com/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/replay/supplier7112/short-caller/signed_child.py" + }, + "inputs/CALLER.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "9451ceaf6e8e037894680b549f3ef41c21b260d7", + "path": "research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json", + "sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "source": "https://github.com/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json" + }, + "inputs/PHYSICAL-BINDING.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "c10f2a7f93b5632fb8789046b6a5c99da42c432a", + "path": "research/signed-caller-8x9/expected/ODD-PHYSICAL-BINDING.json", + "sha256": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "source": "https://github.com/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/expected/ODD-PHYSICAL-BINDING.json" + }, + "inputs/PR7362-SHA256.json": { + "commit": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "git_blob": "b1486e0b5cfe4535f381ed26f7bce4aee21d8a43", + "path": "research/p104-rank-two-virtual-cut-bound/receipts/SHA256.json", + "sha256": "2c90ca39b0f075cc4b3ec9e90c66fde473465e7bb50cf1db9a820d3a29556c0b", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/5eec7ed633dcf9b9bbc95552aa653da296f863fb/research/p104-rank-two-virtual-cut-bound/receipts/SHA256.json" + }, + "inputs/PR7404-RESULT.json": { + "commit": "aadd1de3e520cfd1e5b062729bd76f543dc879f4", + "git_blob": "d9b84899429576280cc0052a6670686cbcdabcc7", + "path": "research/p104-stage8-query-carrier/RESULT.json", + "sha256": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", + "source": "https://github.com/Clear1nsight/integer-mult-bounds/blob/aadd1de3e520cfd1e5b062729bd76f543dc879f4/research/p104-stage8-query-carrier/RESULT.json" + }, + "inputs/pricing.py": { + "commit": "c522451caf287bb3c16eaece72be4c263315dca4", + "git_blob": "40ec194017bda1d524bba4f07b188c53281419d0", + "path": "research/adjacent-owned-add-exchange-bound/pricing.py", + "sha256": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/c522451caf287bb3c16eaece72be4c263315dca4/research/adjacent-owned-add-exchange-bound/pricing.py" + } + }, + "peer7404": { + "author": "Clear1nsight", + "exact_prior_source_pins": [ + [ + "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json", + "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" + ], + [ + "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "research/p104-helper-319-fused-return/WORD.json.gz", + "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a" + ], + [ + "b567f9a4f5699c5e447100c38b5745526b15b770", + "research/p104-type-a-query-fixed-cut/engines/lead/full_body.py", + "352c7d594f357333f027dc46eef0e82226b9552ab31d6890b1695fe994e8c3b4" + ], + [ + "ebb2b1c5b62344f56c62d526558f059c99dd7077", + "research/p104-paired-query-host-rank-bound/engines/host_rank.py", + "ffbcde67a1f0a7595233baf0e5b40e73ab75fe1324139ecf374040a88d62a13e" + ] + ], + "head": "aadd1de3e520cfd1e5b062729bd76f543dc879f4" + }, + "schema_version": 1 +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/README.md b/research/p104-retimed-type-a-stage8-host-bound/README.md new file mode 100644 index 0000000000..14ec6436aa --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/README.md @@ -0,0 +1,57 @@ +# Bound the retimed Type A stage-8 host + +**NO VERIFIED GAIN.** Keep the exact [#7404](https://github.com/CrocSwap/integer-mult-bounds/pull/7404) +retiming at the first Type A port, demote QUERYs 1580 and 1659 to unit ADDs, +and request retirement of the central phase on productive roots 0 and 18. +The required stage-8 host cannot fit four ingress and four egress fields +with fixed phase-even adapters and feedthrough on the compared sectors. +At central sign +1, the body difference has determinant 16 on the original +four-role block. The central sign difference has 320 entries outside that +block, including (8,1) = −2. + +The comparison uses [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) +at aaeec8c0acf01e99a5f331ef363a698d9c084ace and the signed +[#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +caller at 07a76c5e2738882c0cb322278e56f6cae3c9885d. The strongest reproduced +comparable exponent saving remains 0.00364665195644. + +The one-port optimistic price was positive before the support check, +below 0.04270044187346692 raw. A 96-port relaxation assuming compatibility +is below 4.099242419852824 raw. The verified exclusion is for this exact +port, one J clock and one root pair. See [proof and scope](PROOF.md). + +From a clean checkout with CPython 3.12 and assertions, run + + python3.12 -I -B research/p104-retimed-type-a-stage8-host-bound/replay.py + +The replay binds the exact public inputs and reproduces the directed +price, forward matrices and independent reverse-covector receipt. +It also checks the physical sign witnesses and rejects altered caller +bytes. See [verification](VERIFICATION.md) and [provenance](PROVENANCE.json). + +## Open next questions + +Can an enlarged or phase-dependent host implement both aggregate reads, +the scatter and the dirty-input return contract under the same paid bill? +Start with one specified extra ingress or egress path at clock 1423. +Check its support, chronological availability and unchanged returns, +then price all new fields and adapters. Other root pairs, other clocks, +odd feedthrough and different skeletons were outside the test. + +## Credit + +Clear1nsight's [#7404](https://github.com/CrocSwap/integer-mult-bounds/pull/7404) +at aadd1de3e520cfd1e5b062729bd76f543dc879f4 supplies the exact 14-idle +retiming and the original carrier evidence. The retained signed caller +and native comparator are credited to Rohan Arun's +[#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) and +Clear1nsight's [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334). +[#7401](https://github.com/CrocSwap/integer-mult-bounds/pull/7401) supplies +the fixed-skeleton two-root comparison, and +[#7344](https://github.com/CrocSwap/integer-mult-bounds/pull/7344) the +retained-J phase capacity question. +[#7360](https://github.com/CrocSwap/integer-mult-bounds/pull/7360) +supplies the physical character witness method, and +[#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) +the exact price receipt. OpenAI Codex and subagents materially assisted +the proof, implementation and independent verification. Apache-2.0. diff --git a/research/p104-retimed-type-a-stage8-host-bound/SOURCES.json b/research/p104-retimed-type-a-stage8-host-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "path": "certificates/selected-result.json", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "usage": "provenance" + }, + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/TASK.json b/research/p104-retimed-type-a-stage8-host-bound/TASK.json new file mode 100644 index 0000000000..30366b877b --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113, Clear1nsight #7404 retiming at Type A port 0, J8 at 1423, and demotion 1580/1659 with retirement only at roots 0 and 18.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 retimed Type A stage-8 host research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "The two removed rank-one jobs save the binding moment only if the same paid host can realize the requested new arbitrary-input endpoint.", + "budget_minutes": 12, + "evidence": "Independent 36-column forward and reverse checks find determinant 16 on the old body support and 320 entries outside the corresponding phase support.", + "open_questions": [ + { + "blocked_by": "No legal larger interface and complete invoice are known in this test.", + "first_step": "Specify one extra ingress or egress path at the tested J clock and check arbitrary dirty ownership, restoration, and full price.", + "question": "Can an enlarged or phase-dependent host deliver the two aggregates and scatter with the same paid bill?", + "why_it_matters": "The four-field even interface cannot realize the optimistic paid saving." + } + ], + "original_card": { + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "existing_checks": [ + { + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4133: literal-slot defect", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4136: uniform commutation gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4140: uniform encoding gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "status": "author-checked" + }, + { + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "status": "author-checked" + }, + { + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4154: fiber-tag seam mismatch", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "status": "author-checked" + }, + { + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "status": "reviewed" + } + ], + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "id": "p104-side-correction", + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "Test a different productive endpoint within the exact peer retiming and a four-field even host interface.", + "scope_status": "changed", + "stop_rule": "One port, one root pair, one J, two central signs, one extra body setting and 36 columns, at most 10 seconds per support engine.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md b/research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md new file mode 100644 index 0000000000..bd6935af11 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/VERIFICATION.md @@ -0,0 +1,16 @@ +# Verification record + +The exact first-port test uses one root pair, one J clock, 36 basis +columns and the two central signs. The positive central sign has two +stage-8 body settings. The lead checks both old and retimed whole words +and all reconstructed required hosts. A reverse-covector replay uses +row action and independently finds 320 nonzero outside entries and matches +the twelve printed witnesses. Each support runner is capped at ten +seconds. No further root pair or physical build was launched. + +The clean wrapper authenticates exact caller and predecessor bytes by +path, reproduces the price and both support receipts, checks legal +physical sign witnesses from the pinned binary gate and rejects changed +caller bytes. A restoration of one canceled ADD also fails the retimed +endpoint test. The four-field support result is exact in the stated +fixed-sector interface. diff --git a/research/p104-retimed-type-a-stage8-host-bound/VERIFY.json b/research/p104-retimed-type-a-stage8-host-bound/VERIFY.json new file mode 100644 index 0000000000..6e14c60893 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Rebuild the exact one-port price, forward and reverse host matrices and physical sign controls.", + "timeout_seconds": 50 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py b/research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py new file mode 100644 index 0000000000..c169df804c --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/engines/host_forward.py @@ -0,0 +1,225 @@ +"""Price and test one #7404 retimed host with two productive q retirements.""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "PR7404-RESULT.json": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", + "R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} +HOST, QUERIES, BOUND, N = 1423, {1580, 1659}, (8, 0, 18, 26), 36 +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER_HEAD = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +PEER_HEAD = "aadd1de3e520cfd1e5b062729bd76f543dc879f4" + + +def read(name): + path = ROOT / "inputs" / name + raw = path.read_bytes() + assert sha256(raw).hexdigest() == PINS[name], name + return raw + + +def identity(sign=1): + return [[Q(sign if i == j else 0) for j in range(N)] for i in range(N)] + + +def multiply(left, right): + return [[sum(a * b for a, b in zip(row, col, strict=True) if a and b) + for col in zip(*right, strict=True)] for row in left] + + +def difference(left, right): + return [[a - b for a, b in zip(x, y, strict=True)] for x, y in zip(left, right, strict=True)] + + +def tape(events, q, body8, demote=False, inverse=False): + rows = identity() + + def add(dest, src, scale): + rows[dest] = [a + scale * b for a, b in zip(rows[dest], rows[src], strict=True)] + + def scale(role, multiplier): + rows[role] = [x * multiplier for x in rows[role]] + + orient = -1 if inverse else 1 + for clock, event in reversed(events) if inverse else events: + if event[0] == "B": + continue + if event[0] == "J": + _, stage, (u, v, x, y), _ = event + add(v, u, Q(orient * q)) + add(x, y, Q(-orient * q)) + if stage == 8: + for role in (u, v, x, y): + scale(role, body8) + continue + assert event[0] == "A" + _, op, role, *args = event + if op == "ADD": + add(role, args[0], orient * Q(args[1])) + elif op == "QUERY": + assert args[1] == -1 + factor = 1 if demote and clock in QUERIES else q + add(role, args[0], Q(orient * factor)) + elif op == "SCALE": + scale(role, Q(args[0]) ** orient) + elif op == "SWAP": + other, = args + rows[role], rows[other] = rows[other], rows[role] + elif op == "IDLE_ONE": + mask, = args + if 8 in mask: + scale(role, body8) + else: + assert op == "LAMBDA" + return rows + + +def retiming(events, peer): + assert events[HOST][:3] == ["J", 8, list(BOUND)] + assert peer["stage_host"] == HOST and set(peer["queries"]) == QUERIES + assert peer["native_role_binding"] == {"8": 0, "0": 112, "18": 772, "26": 882} + assert all(events[k] == ["A", "QUERY", 0, 1, -1] for k in QUERIES) + moved = peer["hoisted_paid_idles"] + assert len(moved) == 14 + omitted = set() + hoisted = [] + for item in moved: + role, mask, clock = item["role"], item["mask"], item["idle"] + assert HOST < clock <= 1487 and 8 in mask and role not in BOUND + assert events[clock] == ["A", "IDLE_ONE", role, mask] + early, late = item["canceled_adds"] + donor = 0 if role < 18 else 18 + assert HOST < early < late < clock + assert events[early] == ["A", "ADD", role, donor, "2"] + assert events[late] == ["A", "ADD", role, donor, "-2"] + omitted.update((early, late, clock)) + hoisted.append((clock, events[clock])) + assert len(omitted) == 42 + indexed = list(enumerate(events)) + before = indexed[:HOST] + hoisted + after = [(i, event) for i, event in indexed[HOST + 1:] if i not in omitted] + return indexed, before, after + + +def outside(matrix): + return [(i, j, value) for i, row in enumerate(matrix) + for j, value in enumerate(row) if value and (i not in BOUND or j not in BOUND)] + + +def determinant(matrix): + work = [row.copy() for row in matrix] + value = Q(1) + for col in range(len(work)): + pivot = next((k for k in range(col, len(work)) if work[k][col]), None) + if pivot is None: + return Q(0) + if pivot != col: + work[pivot], work[col] = work[col], work[pivot] + value = -value + entry = work[col][col] + value *= entry + for k in range(col + 1, len(work)): + ratio = work[k][col] / entry + work[k] = [a - ratio * b for a, b in zip(work[k], work[col], strict=True)] + return value + + +def quote(caller, roots): + base = json.loads(read("R92-PRICE.json")) + assert base["head"] == HEAD and base["caller_head"] == CALLER_HEAD + pricing = ROOT / "inputs" / "pricing.py" + read("pricing.py") + cost = run_path(str(pricing))["cost"] + type_a = caller["types"]["A"] + ranks = [1 + 8 * sum(row[2:]) for row in type_a["diagonal"]] + ports = len(type_a["ports"]) + assert type_a["roles"] == N and type_a["alpha2"] == "-1" and ports == 96 + crossing = Q(base["old_crossing_upper"]) + stock = Counter({int(r): n for r, n in base["old_targets"].items()}) + stock.subtract({int(r): n for r, n in base["old_paid"].items()}) + results = {} + for count in (1, ports): + delta = Counter({1: 2 * count}) + for root in roots: + delta[ranks[root]] -= count + delta[ranks[root] - 1] += count + assert sum(r * n for r, n in delta.items()) == 0 + edited = stock.copy() + edited.update(delta) + results[count] = { + "signed_histogram_delta": delta, + "gross_at_crossing_upper": cost(delta, crossing), + "complete_at_crossing_upper": cost(edited, crossing), + "complete_at_probe": cost(edited, Q(base["probe"])), + } + return {"roots": roots, "target_ranks": [ranks[r] for r in roots], "ports": results} + + +def stop(*_): + raise TimeoutError("10-second exact gate cap") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--price-only", action="store_true") + args = parser.parse_args() + assert __debug__ + signal(SIGALRM, stop) + alarm(10) + caller = json.loads(read("CALLER.json")) + roots = (0, 18) + pricing = quote(caller, roots) + result = {"native_head": HEAD, "caller_head": CALLER_HEAD, "peer_head": PEER_HEAD, + "caps": {"target_pairs": 1, "phases": 2, "basis_columns": 36, "seconds": 10}, + "host": HOST, "demote_queries": sorted(QUERIES), "price": pricing, "pins": PINS} + if not args.price_only: + events = caller["events"] + assert len(events) == 4783 + indexed, prefix, suffix = retiming(events, json.loads(read("PR7404-RESULT.json"))) + required = {} + original_host = [(HOST, events[HOST])] + for q, body8 in ((1, 1), (1, -1), (-1, 1)): + original = tape(indexed, q, body8) + if body8 == 1: + assert original == identity(q) + pre = tape(prefix, q, body8) + post = tape(suffix, q, body8) + j = tape(original_host, q, body8) + assert multiply(post, multiply(j, pre)) == original + post_demoted = tape(suffix, q, body8, demote=True) + inverse_post = tape(suffix, q, body8, demote=True, inverse=True) + inverse_pre = tape(prefix, q, body8, inverse=True) + assert multiply(post_demoted, inverse_post) == multiply(pre, inverse_pre) == identity() + if q == -1: + for role in roots: + original[role] = [-x for x in original[role]] + need = multiply(inverse_post, multiply(original, inverse_pre)) + assert multiply(post_demoted, multiply(need, pre)) == original + if q == 1: + assert need == j + required[q, body8] = need + body_delta = difference(required[1, -1], required[1, 1]) + assert not outside(body_delta) + body_minor = determinant([[body_delta[i][j] for j in BOUND] for i in BOUND]) + assert body_minor + phase_delta = difference(required[-1, 1], required[1, 1]) + nonzero = outside(phase_delta) + result.update({"bound": BOUND, "body_minor": body_minor, + "outside_nonzero_count": len(nonzero), "first_outside_entries": nonzero[:12], + "decision": "EXCLUDED by four-role support" if nonzero else "SURVIVES support only"}) + alarm(0) + print(json.dumps(result, indent=2, sort_keys=True, default=str)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py b/research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py new file mode 100644 index 0000000000..301b1501a2 --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/engines/host_reverse.py @@ -0,0 +1,123 @@ +"""Reverse-covector check of one retimed Type A host support.""" +from fractions import Fraction as Q +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parent +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PR7404-RESULT.json": "eba0ebfac85759cc9c884b3a12237975ff487c76b17f6095949e80d2fbca60fc", +} +HOST = (8,0,18,26) +CLOCK = 1423 +QUERIES = (1580,1659) +N = 36 + + +def load(name): + raw = (ROOT/name).read_bytes() + assert sha256(raw).hexdigest() == PINS[name] + return loads(raw) + + +def right_inverse(row, word, q, body, demote): + for clock, event in word: + ty = event[0] + if ty == "B": + continue + if ty == "J": + _, stage, (u,v,x,y), _ = event + row[u] -= q * row[v] + row[y] += q * row[x] + if stage == 8: + for role in (u,v,x,y): + row[role] /= body + continue + _, op, dst, *args = event + if op == "ADD": + src, a = args + row[src] -= Q(a) * row[dst] + elif op == "QUERY": + src, phase = args + assert phase == -1 + a = 1 if demote and clock in QUERIES else q + row[src] -= a * row[dst] + elif op == "SCALE": + row[dst] /= Q(args[0]) + elif op == "SWAP": + src, = args + row[dst], row[src] = row[src], row[dst] + elif op == "IDLE_ONE": + if 8 in args[0]: + row[dst] /= body + else: + assert op == "LAMBDA" + return row + + +def basis(i): + return [Q(i==j) for j in range(N)] + + +def required(before, after, q, body, wanted): + output = [] + for i in range(N): + row = right_inverse(basis(i), after, q, body, True) + row = [x * sign for x, sign in zip(row,wanted,strict=True)] + output.append(right_inverse(row, before, q, body, False)) + return output + + +def actual_host(q, body): + table = [basis(i) for i in range(N)] + u,v,x,y = HOST + table[v][u] = q + table[x][y] = -q + for r in HOST: + table[r] = [body * a for a in table[r]] + return table + + +def stop(*_): + raise TimeoutError("10-second exact cap") + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(10) + c = load("inputs/CALLER.json") + p = load("inputs/PR7404-RESULT.json") + events = list(enumerate(c["events"])) + assert p["stage_host"] == CLOCK and sorted(p["queries"]) == list(QUERIES) + assert events[CLOCK][1][0:3] == ["J",8,list(HOST)] + skip, moved = set(), [] + for z in p["hoisted_paid_idles"]: + clock = z["idle"] + moved.append(events[clock]) + skip.update([clock,*z["canceled_adds"]]) + assert events[clock][1] == ["A","IDLE_ONE",z["role"],z["mask"]] + assert len(skip) == 42 + before = events[:CLOCK] + moved + after = [x for x in events[CLOCK+1:] if x[0] not in skip] + for q in (1,-1): + for i in range(N): + assert right_inverse(basis(i), events, q, Q(1), False) == [q*x for x in basis(i)] + plus = required(before,after,1,Q(1),[1]*N) + assert plus == actual_host(1,Q(1)) + alt = required(before,after,1,Q(-1),[-1 if d[9] else 1 for d in c["types"]["A"]["diagonal"]]) + assert alt == actual_host(1,Q(-1)) + minus = required(before,after,-1,Q(1),[1 if i in (0,18) else -1 for i in range(N)]) + witness = [[i,j,str(minus[i][j]-plus[i][j])] for i in range(N) for j in range(N) + if (i not in HOST or j not in HOST) and minus[i][j] != plus[i][j]] + alarm(0) + print(dumps({"pins":PINS,"window_host":CLOCK,"host_roles":HOST,"queries":QUERIES, + "retired_roles":[0,18],"outside_nonzero_count":len(witness), + "first_outside_entries":witness[:12],"plus_body_control":"exact old host at both signs of B8", + "hard_cap_seconds":10,"basis_columns":N},sort_keys=True,indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-SHA256.json b/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-SHA256.json @@ -0,0 +1,69 @@ +{ + "replay/supplier7108/CALLER.json": "9557f713ab4ffb91ede05e8a6d5668c694b9940fc16f2f2d657e2f2b2cac2d3f", + "replay/supplier7112/RESULT.json": "7b808ff32d9803084aaaf820cd172ddc9001c7aebbd17e0324e779abeff91b30", + "replay/supplier7112/WORD.json.gz": "fe0b1dc3049a6b72760a705af2e698e0e9998e969e19862a696eba63434eb233", + "replay/supplier7112/short-caller/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "replay/supplier7112/short-caller/ODD-LOCALIZED-GROUPING.json": "8aac6b3d9e528bffbcf411bbd300c8e0f0b7bf75da45ab12badf3f3530ffcbe2", + "replay/supplier7112/short-caller/ODD-UNIT-DYADIC-TAPES.json": "c3195057f7a6723a81172ed540d0f1c4ba699ff3cb8dc37cbde7bb481d9b976c", + "replay/supplier7112/short-caller/ODD-UNIT-PREFIX-CLOSURES.json": "3b953e5d3e83e7573a3e908a5a23edb78773d4d22816aca54f766f0f0e9f5403", + "replay/supplier7112/short-caller/SHORT-ADMISSION-PARTIAL.json": "7977815fe72382738727e3d550eea3bc735923c9c57968872d4f863cb39cd401", + "replay/supplier7112/short-caller/SHORT-CALLER-RAW-PRICE.json": "a4f83d65d250efb40f6506658374d7414afdde11c96eb88b7d2fbb182aa090c1", + "replay/supplier7112/short-caller/SHORT-CATALOGUE-0-1000.log": "a916a76627fb79bf606b22f857ca93db6342891fb2c85b20658b5002c359e422", + "replay/supplier7112/short-caller/SHORT-CATALOGUE-1000-2000.log": "da633bfa408e98a2f2a958262a09d5e4274a9b25f7b4a6a73df5a97f37338f79", + "replay/supplier7112/short-caller/SHORT-CATALOGUE-2000-3047.log": "e8d500c0261a4a9e0cf3da2838d82806ed497ab9cf57cb8620ca6debfb98525c", + "replay/supplier7112/short-caller/SHORT-PRECISION.json": "68a00d2b83ee2eb944d2e05fc7f32bc9aa37282c45b968f0ab6fd500659ac028", + "replay/supplier7112/short-caller/SHORT-TYPE-A-ROOT.json": "e9812d720942d8149c219dfa28c1081ff1d353529e5282ca4624a04233f38f88", + "replay/supplier7112/short-caller/admission-source/ARCHIVE-CHAIN.json": "6de95c4eb396e69883fbeeb3989782bbbe232c22644af1c804050badca10f456", + "replay/supplier7112/short-caller/admission-source/FULL-RESULT.json": "d9ba709fa5dcefffe3f3abdcf34600ce188224703cfd743e6db8b58ba4816cb7", + "replay/supplier7112/short-caller/admission-source/INDEPENDENT-NOTICE.md": "cadbc642ca84311d2c7a6cf704c7828cb4cf77e3c784b66e4c6e8a5c28002fb8", + "replay/supplier7112/short-caller/admission-source/INDEPENDENT-SOURCES.json": "dced1457df5230466ba6202fd6d4595bc2b7fb2a65302806bf2720b1837ff350", + "replay/supplier7112/short-caller/admission-source/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "replay/supplier7112/short-caller/admission-source/NATIVE-INPUTS.json": "9bb6c1567783661334d6c1d23f715ce5635cbbb513678819ab9e020a34c7e4c0", + "replay/supplier7112/short-caller/admission-source/NOTICE": "da12736e2e824167ff56f2ecb623a5f88f75a270410360890f61dffc33bab249", + "replay/supplier7112/short-caller/admission-source/data/bit-admission.json": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b", + "replay/supplier7112/short-caller/admission-source/data/caller.json": "3828d53e80ea97e8b866320f081af20b6b93bfebd58b95b56b85a7afe151af5e", + "replay/supplier7112/short-caller/admission-source/data/final.json.gz": "2b94953dc14a122e3ef089633f05b58ec689ec5156feb7c784ed3e137dc01883", + "replay/supplier7112/short-caller/admission-source/frozen/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "replay/supplier7112/short-caller/admission-source/frozen/native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "replay/supplier7112/short-caller/admission-source/frozen/physical.py": "4e995d1158033d83bf69b671f23dc7924d66edbbe07623ba063ba7421234ea20", + "replay/supplier7112/short-caller/admission-source/frozen/verify_host3_odd.py": "e75ad2096ba2587d1dc9c8982b2c2eb7c6fd2636a80adcd943314ef2cf6fd258", + "replay/supplier7112/short-caller/admission-source/independent.py": "21f46a8340331abb1486b50bd4e04453f1968b0a5950d86ff7780dd368590874", + "replay/supplier7112/short-caller/admission-source/interval_gate.py": "60a743d13f668ef86db4b8215b4d5d04430a671ba6f1fe06d9c1c4c3dfe86da5", + "replay/supplier7112/short-caller/admission-source/precision_replay.py": "850d9098c5946ab27ef5228acc54d59df2196e72259d3e21588ec0c319c8f5ee", + "replay/supplier7112/short-caller/admission-source/retained/odd-native-common-grid/independent_bounds.py": "198521def614fe78fa728f1dde2b7fb820c0c0e0ac3ad0c9224dccbf51eac0d5", + "replay/supplier7112/short-caller/admission-source/retained/query-only-precision-envelope/envelopes.py": "783da6b5b450fc07434946cb9ec86070dfee01df6b5fa1c385cb024def2c9a9f", + "replay/supplier7112/short-caller/admission-source/retained/query-only-precision-envelope/source_binding.py": "624c459311c58f3847b7713b818bfd340153abf42919f02ac9aa8892ed52a2bd", + "replay/supplier7112/short-caller/assemble_odd_application.py": "6cdac39ab196a70c53ba2283c2555cd8dee30644dcc4769628b46fb53bd55a1f", + "replay/supplier7112/short-caller/candidate_gate.py": "e71097ca81a082afd7c647324a6c94cb357aeb1084693a095a0f3e0b45a9b11a", + "replay/supplier7112/short-caller/check_odd_caller_exact_grid.py": "abd5a5fd011b71e5b382cbc058855594d4f2fe7b049f375506675c0303180f54", + "replay/supplier7112/short-caller/check_odd_fixed_tape_counts.py": "e6246e9f8fbeae3077d82e585eafd3647c1a8758c58f33c7c13e7efa6c1e42bb", + "replay/supplier7112/short-caller/check_odd_partial_admission.py": "4416b1ea5f07f8a91028a2e500116588fbdfaed95a8ef9bac7a46bcb44b9478e", + "replay/supplier7112/short-caller/check_odd_physical_binding.py": "5c80c3b0415a7f91d216395248dd6f13297eed637732098e1ca8fb0548951b98", + "replay/supplier7112/short-caller/check_odd_precision.py": "b2d9c13577158157a587ace766d9dadb7819a0164b372722329d9754e1be6c61", + "replay/supplier7112/short-caller/connected.py": "469537b46fb92c5aca926d3b1497da5425408673b0a73ba1427f23d872b414e7", + "replay/supplier7112/short-caller/cut_library.py": "7ccb81af19db54ec7cdb44849af018d4ca8893f80f17277914f8566715985133", + "replay/supplier7112/short-caller/emit_odd_type_ab.py": "7a7993648433c6febad8c07b315aec1b96598835a3f587b62040423c33c3b71f", + "replay/supplier7112/short-caller/emit_odd_type_b.py": "d1fa8b67d98beacd6bb574b3d5fcbc94b8646a7ffbce91d2a6fd4d690d3c5329", + "replay/supplier7112/short-caller/host34.py": "bded1a8626d65ee40c4ba3b25780fc03f0fa08906f3c83f631892df072d9a9b7", + "replay/supplier7112/short-caller/independent.py": "21f46a8340331abb1486b50bd4e04453f1968b0a5950d86ff7780dd368590874", + "replay/supplier7112/short-caller/interval_gate.py": "60a743d13f668ef86db4b8215b4d5d04430a671ba6f1fe06d9c1c4c3dfe86da5", + "replay/supplier7112/short-caller/lower.py": "67345fdfc8e5bb816e24b37dfafad0396372c48ec4e1b95b8b69f019a8fdfdee", + "replay/supplier7112/short-caller/mirrored.py": "55dd441a3a7f504b351857d45fd701994a0950ae1baec6c4c2b4b0166fb69db3", + "replay/supplier7112/short-caller/odd_unit_dyadic_tapes.py": "3cdafa35635360a487ce400ec8d585f6134dd7c58209543528e98e7db178bbc7", + "replay/supplier7112/short-caller/screen.py": "01e3eaba4b710a080e6e393e53157e6a119fdf312620eed26e9185ca91f6bea6", + "replay/supplier7112/short-caller/short_dyadic_seam.py": "6e588b365618ab2df4fa2d1f16073d09a953a7cd6e826e1f96bbf87f950b672b", + "replay/supplier7112/short-caller/short_native_catalogue.py": "775695c379f407801910531565cc371012cee501b2cec5f5d718ecdccf06b64d", + "replay/supplier7112/short-caller/signed_child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "replay/supplier7112/short-caller/signed_model.py": "f88c798b9a22c656ea0b755b4f32be411c1f80687dff1a1ac9e9c2a0b5f4203e", + "replay/supplier7112/short-caller/stage.py": "0ab5546e926dd98d3ad833909b534840b7d8d0467c4790ca09bc2b14b37313f5", + "replay/supplier7112/short-caller/upstream_application.py": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184", + "replay/supplier7112/short-caller/upstream_native_catalogue.py": "6120e1ea1e07eeba757694d209437a38f121b0a377cc466889a30fa52c561472", + "expected/ODD-8X9-APPLICATION-CHECKS.json": "10512d62f540fe7bb839ec94b6a21bbdf4a3dfadf56b4ec9095d4b242bda19b8", + "expected/ODD-ADMISSION-PARTIAL.json": "75ec76e4393ef1622fcff9e2727dc411921076af4a506d97506665add140fa86", + "expected/ODD-CALLER-EXACT-GRID.json": "87d25d9fa3778bf4784e3a9e17f32ce5ba372663c6e97392cc62b87e6719042c", + "expected/ODD-FIXED-TAPE-COUNTS.json": "1a8bf36a966edca8c61f3be803cdbe136307095dec40245cdc93e79a9062fe99", + "expected/ODD-PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "expected/ODD-PRECISION.json": "9c03607288cc2afb80cb02c197f93360978233036418b32b09ad91be16f9c153", + "expected/ODD-TYPE-AB-CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "expected/ODD-TYPE-AB-REPLAY.json": "71fd0a7ad8b743266c6a75100f3543b48ea7d6fcbe45f008d3b61270e3b660a0" +} diff --git a/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-application.py b/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-application.py new file mode 100644 index 0000000000..1a6d358cbe --- /dev/null +++ b/research/p104-retimed-type-a-stage8-host-bound/inputs/7113-application.py @@ -0,0 +1,369 @@ +#!/usr/bin/env python3 +"""Exact-source caller geometry, occurrence allocation and rational BIT frames. + +No contributor scientific module is imported. Complex phase-polynomial +method credited to the retained fragment physical audit; here coefficients +of the full degree-two polynomial are constructed instead of probing it. +OpenAI Codex assistance for Douglas Colkitt. Apache-2.0. +""" +from collections import Counter +from copy import deepcopy +from fractions import Fraction as Q +from hashlib import sha256 +from pathlib import Path +import gzip +import json + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + raw = (ROOT / path).read_bytes() + pin = next(p for p in json.loads((HERE / 'SOURCES.json').read_text())['files'] + if p['path'] == path) + need(sha256(raw).hexdigest() == pin['sha256'], 'source bytes: ' + path) + return json.loads(gzip.decompress(raw) if path.endswith('.gz') else raw) + + +def digest(value): + return sha256(json.dumps(value, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + + +def bits(n): + result = [] + while n: + a = n & -n + result.append(a) + n ^= a + return result + + +def dot(a, b): + return (a & b).bit_count() % 2 + + +def terms(items): + c = Counter() + for v, a in items: + c[v] += a + return {v: a % 4 for v, a in c.items() if v and a % 4} + + +def sub(a, b): + return terms(list(a.items()) + [(v, -c) for v, c in b.items()]) + + +def polynomial(t): + # parity(sum x_i) = sum x_i - 2 sum_{i 0, 'positive complete helper job') + T[rank] += 1 + need(len(mapping) == len(set(mapping.values())) == word['public'], 'injective native inputs') + for r in range(word['public'], word['public']+word['owned_fields']): + mapping[r] = ('owned', ci, r-word['public']) + need(len(set(mapping.values())) == word['public']+51, 'owned/public separation') + for ni, move in native_moves: + _, r, start, end, owned = move + rank = abs(len(word['frames'][end])-len(word['frames'][start])) + need(owned == (r >= word['public']) and rank > 0, 'actual paid owner class') + P[rank] += 1 + occurrences.append([ci, ni, list(mapping[r]), rank, start, end]) + for pi, q in enumerate(word['ports']): + transform = route(q, by_q[q], stage) + before_axes = [1 << j for j in range(9+8*(stage-1))] + after_axes = [1 << j for j in range(9+8*stage)] + spectator = [1 << j for j in range(9, 9+8*stage)] + x0 = terms((a, 1) for a in before_axes) + y0 = terms(list(x0.items())+[(q, -1)]) + x1 = terms((a, 1) for a in after_axes) + y1 = terms(list(x1.items())+[(q, -1)]) + nx0 = terms([(a, 1) for a in spectator]+[(q, 1)]) + ny0 = terms((a, 1) for a in spectator) + nx1 = terms((a, 1) for a in spectator+[1 << j for j in range(9)]) + ny1 = terms(list(nx1.items())+[(q, -1)]) + shifts = [boundary(a, b, transform) for a, b in + ((x0, nx0), (y0, ny0), (nx1, x1), (ny1, y1))] + body = terms((1 << j, 1) for j in range(9+8*(stage-1), 9+8*stage)) + for actual, expected in ((sub(x1,x0),body), (sub(y1,y0),body), + (sub(y1,x0),terms(list(body.items())+[(q,-1)])), + (sub(x1,y0),terms(list(body.items())+[(q,1)]))): + need(not polynomial(sub(actual,expected)), 'all four contact operators') + need(polynomial(sub(terms([(q,1)]),terms([(q,-1)]))), 'wrong query orientation rejected') + phase_records.append([ci,pi,shifts,2 if pi in second else 1]) + else: + ty, op, r, *a = e + kind = caller['types'][ty] + used = [r] + ([a[0]] if op in ('ADD','SWAP','QUERY') else []) + need(all(kind['offset'] <= x < kind['offset']+kind['roles'] for x in used), 'caller owners stay in type') + need(len(used) == len(set(used)), 'distinct scalar/query owners') + if op in ('QUERY','IDLE_ONE'): + if op == 'QUERY': + need(a[1] in (-1,1), 'signed completed query') + rank = 1; query_uses += len(kind['ports']) + else: + selected = a[0] + need(selected and len(selected)==len(set(selected)) + and all(1 <= s <= 18 for s in selected), 'whole idle stage axes') + rank = 8*len(selected); idle_uses += len(kind['ports']) + for pi in kind['ports']: + owner = ['query_scratch',ci,pi] if op == 'QUERY' else ['main',pi,r] + occurrences.append([ci,op,owner,rank]); P[rank] += 1 + elif op == 'LAMBDA': + need(a[0] in (-1,1), 'global normalizer sign') + lambda_uses += len(kind['ports']) + need(stage_order == list(range(1,19)), 'fresh chronological native stages') + for kind in caller['types'].values(): + for diagonal in kind['diagonal']: + qp, zero, *selection = diagonal + need(qp in (-1,0,1) and zero == 0 and len(selection)==18 + and set(selection)<={0,1} and any(selection), 'positive nonempty root endpoint') + rank = abs(qp)+8*sum(selection) + for pi in kind['ports']: + q = word['ports'][pi] + axes = [1 << (9+8*j+k) for j,yes in enumerate(selection) if yes for k in range(8)] + actual = terms([(q,qp)]+[(a,1) for a in axes]) + target = terms((a,1) for a in ([q] if qp else [])+axes) + need(translation(sub(target,actual)) == (q if qp == -1 else 0), 'whole output correction') + T[rank] += 1 + for name, actual in [('P',P),('T',T)]: + need(actual == Counter({int(k):v for k,v in receipt['invoice'][name].items()}), 'independent '+name+' invoice') + need(sum(T.values()) == len(owners), 'every productive target is one actual owner') + need(len(occurrences) == sum(P.values()), 'every paid position retained in order') + return dict(ambient=153, native_calls=18, native_public=1480, fresh_helpers=19440, + productive_fields=len(owners), paid_positions=len(occurrences), + complete_paid_position_digest=digest(occurrences), + native_contact_boundaries=sum(4*r[3] for r in phase_records), + phase_record_digest=digest(phase_records), nonzero_boundary_translations=sum(sum(bool(x) for x in r[2])*r[3] for r in phase_records), + reserved_native_banks=18*51, reserved_serial_query_lambda_bank=1, + query_uses=query_uses, idle_uses=idle_uses, lambda_uses=lambda_uses, + paid=dict(sorted(P.items())), targets=dict(sorted(T.items())), + rank_surplus=sum(r*T[r] for r in T)-sum(r*P[r] for r in P)) + + +def inverse(matrix): + n = len(matrix) + a = [[Q(x) for x in row]+[Q(i==j) for j in range(n)] for i,row in enumerate(matrix)] + det = Q(1) + for j in range(n): + pivot = next((i for i in range(j,n) if a[i][j]),None) + need(pivot is not None, 'rational basis invertible') + if pivot != j: + a[j],a[pivot] = a[pivot],a[j]; det = -det + v = a[j][j]; det *= v; a[j] = [x/v for x in a[j]] + for i in range(n): + if i != j: + v = a[i][j] + a[i] = [x-v*y for x,y in zip(a[i],a[j])] + return [row[n:] for row in a], det + + +def bit_application(word, caller, receipt): + ff = word['frames']; determinants=[]; denominator_witnesses=set() + for label, frame in ff.items(): + B,A = frame['B'],frame['A']; d = frame['dim'] + need(len(B)==d and len(A)==8-d and all(len(v)==8 for v in B+A), 'rational frame dimensions') + need(all(sum(Q(x)*Q(y) for x,y in zip(b,a))==0 for b in B for a in A), 'complement annihilation') + inv, det = inverse(list(zip(*(B+A)))) + determinants.append([label,str(det)]) + denominator_witnesses.add(abs(det.numerator)); denominator_witnesses.add(det.denominator) + for row in inv: + denominator_witnesses.update(x.denominator for x in row) + for row in B+A: + denominator_witnesses.update(Q(x).denominator for x in row) + charts=[] + for port in range(111): + head=ff[str(word['start'][port])]; body=ff[str(word['final'][port+111])] + need(head['dim']==1 and body['dim']==7, 'actual main head/body ranks') + u=head['B'][0] + need(all(sum(Q(x)*Q(y) for x,y in zip(u,v))==0 for v in body['B']), 'main complement') + inv,det=inverse(list(zip(*([u]+body['B'])))) + charts.append([port,str(det)]) + denominator_witnesses.update([abs(det.numerator),det.denominator]) + for row in inv:denominator_witnesses.update(x.denominator for x in row) + P,T=Counter(),Counter(); positions=[]; names={('main',pi,r) for pi in range(111) for r in range(38)} + calls=[] + for ci,e in enumerate(caller['events']): + op=e[0] + if op=='LOCAL': + _,stage,src,dst=e; calls.append(stage) + mapping={i:('main',i,src) for i in range(111)} + mapping.update({i+111:('main',i,dst) for i in range(111)}) + for r in range(222,word['public']): + owner=('helper',ci,r); need(owner not in names,'fresh BIT helper');names.add(owner);mapping[r]=owner + T[abs(ff[str(word['start'][r])]['dim']-ff[str(word['final'][r])]['dim'])]+=1 + need(len(mapping)==len(set(mapping.values()))==659,'injective BIT occurrence') + for r in range(659,659+word['owned_fields']):mapping[r]=('owned',ci,r-659) + for ni,move in enumerate(word['program']): + if move[0]=='MOVE': + _,r,a,b=move;rank=abs(ff[str(a)]['dim']-ff[str(b)]['dim']) + P[rank]+=1;positions.append([ci,ni,list(mapping[r]),rank,a,b]) + elif op=='QUERY': + need(e[1]!=e[2] and 0<=min(e[1:])<=max(e[1:])<38,'BIT query owners') + for pi in range(111):P[1]+=1;positions.append([ci,op,['query_scratch',ci,pi],1]) + elif op=='IDLE_ONE': + _,owner,ss=e;need(ss and len(ss)==len(set(ss)) and all(1<=s<=18 for s in ss),'BIT idle axes') + for pi in range(111):P[7*len(ss)]+=1;positions.append([ci,op,['main',pi,owner],7*len(ss)]) + need(calls==[s for s in range(1,19) for _ in range(2)],'paired native chronology') + for d in caller['diagonal']: + need(d['q']==1 and d['stages'] and len(d['stages'])==len(set(d['stages'])),'BIT positive endpoint') + T[1+7*len(d['stages'])]+=111 + need(P==Counter({int(k):v for k,v in receipt['paid'].items()}) and + T==Counter({int(k):v for k,v in receipt['targets'].items()}),'complete BIT invoice') + need(sum(T.values())==len(names)==19950,'BIT owner count') + return dict(ambient=134, rational_frames=len(ff), rational_main_charts=len(charts), + rational_determinants_digest=digest(determinants), + finite_prime_exclusion_witness_count=len(denominator_witnesses), + finite_prime_exclusion_witness_digest=digest(sorted(denominator_witnesses)), + native_calls=len(calls), fresh_helpers=36*437, productive_fields=len(names), + paid_positions=len(positions), complete_paid_position_digest=digest(positions), + reserved_native_banks=36*word['owned_fields'], reserved_serial_query_bank=1, + rank_surplus=sum(r*T[r] for r in T)-sum(r*P[r] for r in P)) + + +def main(): + p='research/shared-wire-split-composition/' + w,c,r=read(p+'data/final.json.gz'),read(p+'data/caller.json'),read(p+'FULL-RESULT.json') + phases=read('research/p104-two-chain-shared-native/retained/runtime/DATA-PHASES.json') + complex_result=complex_application(w,c,r,phases) + p='research/paired-query-only-bit/' + bw,bc,br=read(p+'retained/inputs/BIT-NATIVE-WORD.json.gz'),read(p+'EFREE-CALLER.json.gz'),read(p+'EFREE-RESULT.json') + bit_result=bit_application(bw,bc,br) + controls={} + def reject(name, action): + try:action() + except ValueError as error:controls[name]=str(error) + else:raise ValueError('negative control accepted: '+name) + alias=deepcopy(c);joint=next(e for e in alias['events'] if e[0]=='J');joint[2][2]=joint[2][0] + reject('same_frame_main_alias',lambda:complex_application(w,alias,r,phases)) + reordered=deepcopy(c);joint=next(e for e in reordered['events'] if e[0]=='J');joint[1]=2 + reject('wrong_stage',lambda:complex_application(w,reordered,r,phases)) + bad_bit=deepcopy(bw);bad_bit['frames']['0']['A'][1]=bad_bit['frames']['0']['A'][0][:] + reject('singular_BIT_spectator_basis',lambda:bit_application(bad_bit,bc,br)) + q=w['ports'][0];basis=next(x for x in phases['recipes'] if x['q']==q)['idle_children'][0]['orthogonal_axes'][:8] + reject('singular_complex_route',lambda:route(q,basis[:-1]+basis[:1],1)) + transform=route(q,basis,1) + before=terms((1<> (a*width)) ^ (label >> (b*width))) & mask + return label ^ (delta << (a*width)) ^ (delta << (b*width)) + + +def permute(label, swaps, width): + for a, b in swaps: + label = swap_blocks(label, a, b, width) + return label + + +def masks(stage, width): + return ((1 << width)-1, ((1 << (8*width))-1) << ((9+8*(stage-1))*width)) + + +def descriptor(stage): + assert 1 <= stage <= 18 + return tuple((j, 8*stage+j) for j in range(1, 9)) + + +def packed_kernel(row, col, width, mutate=None): + if (row ^ col) >> (9*width): + return (0, 0) + result = (1, 0) + for j in range(9*width): + result = multiply(result, C[(row >> j) & 1][(col >> j) & 1]) + q = (1 << width)-1 + if (row ^ col) & q and ((row ^ col) & q).bit_count() % 2: + result = -result[0], -result[1] + exponent = width if mutate != 'missing multiplicity' else 1 + return multiply(PHASE[exponent % 4] if mutate != 'missing global phase' else (1,0), result) + + +def separate_kernel(row, col, stage, width): + q, body = masks(stage, width) + if (row ^ col) & ~(q | body): + return (0,0) + result = (1,0) + for bit in range(width): + result = multiply(result, conjugate(C[(row >> bit) & 1][(col >> bit) & 1])) + start = (9+8*(stage-1))*width + for bit in range(start, start+8*width): + result = multiply(result, C[(row >> bit) & 1][(col >> bit) & 1]) + return result + + +def verify_route(stage, width): + swaps = descriptor(stage) + q, body = masks(stage, width) + front = (1 << (9*width))-1 + assert permute(q | body, swaps, width) == front + assert permute(q, swaps, width) == q + for i in range(LAYOUT*width): + x = 1 << i + assert permute(permute(x, swaps, width), reversed(swaps), width) == x + return swaps + + +def check_finite(stage, width, rng): + swaps = verify_route(stage, width) + q, body = masks(stage, width) + prefix = 9*width + active = q | body + parked = rng.getrandbits(LAYOUT*width) & ~active + if width == 1: + pairs = ((r,c) for r in range(1<