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-type-a-late-mask-permutation-bound/LOCAL-PINS.json b/research/p104-type-a-late-mask-permutation-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..1623fbd27e --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/LOCAL-PINS.json @@ -0,0 +1,22 @@ +{ + "PROVENANCE.json": "69e9c0f8af3a988c4c857e14d423222d1d87c82ee8e6f0fb6f2345c938b4cf5a", + "engines/family_forward.py": "4ad876916978676b47350ad8c88c496a6b8761f52cf4a60b4d2e3595cbba7ffb", + "engines/family_reverse.py": "720a921b8eb215675bf738c94dac3361592c342fd8f8eeda6d6efb6888061a5a", + "engines/permutation_forward.py": "8971b738d9794babbc79b22994e2623a53817e1f90bd0b4d65628b0fb85509cb", + "engines/permutation_reverse.py": "6616262056f2700df3378c50b59f3c43a808c353ef8f138bf53f59a94f205809", + "engines/seam_reverse.py": "2faedaf76b8d1cc399294f5595862092de75ea1dd3a0ec41898a61edad006d53", + "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/R179-FORWARD.json": "04bca202f47e522deabcbf62be98f723836d531a3dc950791366ccb1e7e85ed5", + "receipts/R179-REVERSE.json": "7eaef9e3e57ca03cdeeee7f03aec53949df7059b653dac267da66561663d3b3b", + "receipts/R181-FORWARD.json": "d0d679b13497f474a03afd0125ea6d9449f11e8fbcdc244ef7ec830dbec6a672", + "receipts/R181-REVERSE.json": "c0bac7cd0406d6ea17d363b7251f1455c54612f6da305289d5bf25d0c866fc87" +} diff --git a/research/p104-type-a-late-mask-permutation-bound/NOTICE b/research/p104-type-a-late-mask-permutation-bound/NOTICE new file mode 100644 index 0000000000..da4e37ae6e --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/NOTICE @@ -0,0 +1,4 @@ +Apache-2.0 contribution. Clear1nsight supplied the exact #7334 comparison. +Rohan Arun supplied the exact signed caller and physical gate in #7113. +See README.md and PROVENANCE.json for the exact source and price credits. +OpenAI Codex and subagents materially assisted proof and independent replay. diff --git a/research/p104-type-a-late-mask-permutation-bound/PROOF.md b/research/p104-type-a-late-mask-permutation-bound/PROOF.md new file mode 100644 index 0000000000..897c8d43f7 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/PROOF.md @@ -0,0 +1,35 @@ +# Fixed-cut seam condition and exact exclusion + +Use the original 4,783-event caller and the cut before event 1741, whose first post-cut event is `A ADD 10 0 2`. Keep all paid positions, their itinerary, and the Type A central factors. The tape splits into an early prefix containing body stages 1–8 and four Type A QUERYs and a suffix containing body stages 9–17 and zero Type A QUERYs. Each idle wrapper references only bodies from its side. Denote the two disjoint body-variable sets by b and c. + +Write P(q,b) for the prefix and S(q,c) for the suffix on the full 36-role Type A space. The published arbitrary-input diagonal endpoint is + +\[ + S(q,c) P(q,b) = q^{-1}D_l(c) D_e(b), +\] + +where D_e and D_l encode the early and late masks. The bodies commute under the retained caller contract. Setting the opposite set of body variables to identity gives P(q,b)=G(q)D_e(b) and S(q,c)=q^{-1}D_l(c)G(q)^{-1}, with G(q)=P(q,1). For this necessary condition it suffices to specialize every body to the identity sector and retain all 36 arbitrary role coordinates. + +For one swap X, the reassignment exchanges late masks and the final order of the two outputs. A seam W must satisfy + +\[ + X S(q,c) W(q) P(q,b) = q^{-1} X D_l(c) X D_e(b). +\] + +At unit bodies, every displayed factor other than W is invertible and the equation uniquely forces W(q)=G(q)XG(q)^{-1}. Substitution then gives the requested action for every early and late body setting on which the seam can be realized. A fixed phase-even seam would have W(+1)=W(−1). Both signs are available in the physical #7113 gate. Its C has Walsh eigenvectors (1,1) and (1,−1) with respective eigenvalues 1 and i. At width two, taking zero or two minus factors in the central copies supplies signs +1 and −1 while keeping all body factors in their identity eigenspaces. The signed direction is preserved by the retained routing and the body axes are disjoint from the central block. The necessary equality therefore applies on legal physical input sectors, with arbitrary amplitudes independently placed in all 36 roles. + +There are two exact ways to test the equality. If d=e_a−e_b, X=I−dd^T gives W−I=−(Gd)(d^T G^{-1}), the forward test. With H=G(−1)^{-1}G(+1), multiplying the equality on the left by G(−1)^{-1} and on the right by G(+1) gives XH=HX, the reverse test. Each computation works over the rationals. The latter derives G by reverse covector action and uses exact elimination to obtain H, independent of the forward inverse-event action. + +For each unordered pair the two old and new productive ranks have the same sum. A root with e early and l late active bodies contributes rank 1+8(e+l). At fixed rank sum, strict concavity of r^(1−κ) for 0<κ<1 makes the combined productive weight increase exactly when the difference between the ranks decreases. The 570 other pairs cannot give a strict improvement at unchanged paid stock even if the inserted seam were free. Both exact tests reject the other 60 at q=±1. This settles the full fixed-cut profitable single-swap scope without building a new caller or deriving a new complete exponent. + +The single-pair replay imposes a fixed action on the two signed sectors and retains the old itinerary and final ordinary output swap. + +## Bound for all late-mask permutations at the same cut + +Let Π be any permutation matrix. The output reorder is Π^-1 and the desired late diagonal is Π^-1 D_l Π. The unit-body equation now uniquely forces W(q)=G(q)ΠG(q)^-1. Consequently every phase-even feasible Π commutes with H=G(−1)^-1G(+1). Such a permutation preserves every directed matrix entry under simultaneous row and column permutation. It also preserves the diagonal entries. + +Start with one class of 36 roots. Refine each class by the signature comprising its diagonal entry and, for every current class, the multiset of pairs (H_ij,H_ji) incident to that class. A permutation commuting with H preserves each class at every iteration by induction. Exact refinement gives invariant classes of sizes 2, 16, 10 and 8. Every commuting permutation therefore belongs to the relaxation allowing arbitrary permutations within those classes. + +Within each class, opposite-sort the early and late body counts. For any early counts e≤e′ and late counts l≤l′, the pair (e+l′,e′+l) has the same sum and weakly smaller spread than (e+l,e′+l′). Each such exchange weakly increases the concave productive moment. Repeated exchanges prove opposite sorting maximizes the relaxed within-class objective for every 0<κ<1. The exact opposite-sorted productive rank histogram equals the old one. Therefore the gross gain is at most zero even before charging the seam or output reorder. The exact upper bound settles the whole class without enumerating any permutations. + +The replay also checks that one body count is constant in each invariant class. This proves every class-preserving permutation keeps the exact rank histogram. Other cuts, phase-sensitive seams and changed paid itineraries remain open. diff --git a/research/p104-type-a-late-mask-permutation-bound/PROVENANCE.json b/research/p104-type-a-late-mask-permutation-bound/PROVENANCE.json new file mode 100644 index 0000000000..ebde7d76c5 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/PROVENANCE.json @@ -0,0 +1,85 @@ +{ + "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": { + "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" + } + }, + "predecessors": { + "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-late-mask-permutation-bound/README.md b/research/p104-type-a-late-mask-permutation-bound/README.md new file mode 100644 index 0000000000..9b662a7a76 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/README.md @@ -0,0 +1,30 @@ +# Bound Type A late-mask permutations at cut 1741 + +**Outcome** — Scoped exclusion. The complete bound is unchanged. + +On the exact #7334 caller, balancing a pair of productive ranks can raise the productive moment without changing paid stock. At cut 1741, 60 of the 630 Type A root transpositions improve this optimistic price, 282 tie, and 288 worsen. The required seam fails phase-evenness at two legal signed sectors for every profitable pair. For simultaneous permutations, the signed constraint gives four invariant classes of sizes 2, 16, 10 and 8. Each class fixes either the early or late body count, so any within-class permutation leaves the productive rank histogram unchanged. The optimistic gain is at most zero for every 0<κ<1, even with a free seam. + +For the control pair 0/9, the ranks 137 and 9 would become 73 and 73. The directed relaxed gain is less than 24 raw moment units across 96 Type A ports. The signed seam matrices differ in 100 entries, including entry (0,0) with difference 4. The other 59 profitable pairs each have an exact signed witness in both independent receipts. [Proof](PROOF.md), [verification](VERIFICATION.md) + +## Replay + +From a clean checkout, use CPython 3.12 with assertions and its standard library. + +```sh +python3.12 -I -B research/p104-type-a-late-mask-permutation-bound/replay.py +``` + +The replay authenticates the bundled inputs by path, derives the seam using independent forward and reverse calculations, compares every pair and both whole-family upper bounds, and rejects a deliberately corrupted caller. No external checkout, network or prior scratch data is needed. Expected final line is `PASS_P104_TYPE_A_LATE_MASK_PERMUTATION_BOUND`. + +## Open next questions + +- Does a different seam cut preserve the separation of the early and late body variables while producing a different signed prefix comparison? Pin one exact cut, verify the variable partition, then bound the maximum compatible productive price before attempting a build. +- Can a phase-sensitive seam pay its way? Derive the full four-phase action for one profitable pair and charge every additional paid call, ordinary operation, ownership move and restoration. This needs a different premise from the fixed phase-even family tested here. + +## Predecessors + +- Clear1nsight’s exact #7334 head `aaeec8c0acf01e99a5f331ef363a698d9c084ace` supplies the comparison, κ = 0.00364665195644. [Exact comparison PR](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) +- Rohan Arun’s exact #7113 head `07a76c5e2738882c0cb322278e56f6cae3c9885d` supplies the retained literal Type A/B caller and its physical signed child. The source blobs and SHA256 bindings are recorded in `PROVENANCE.json`. [Signed caller PR](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +- #7362 supplies the exact directed comparator-price receipt from head `5eec7ed633dcf9b9bbc95552aa653da296f863fb`. The rational tariff implementation is retained from `c522451caf287bb3c16eaece72be4c263315dca4`. [Price receipt PR](https://github.com/CrocSwap/integer-mult-bounds/pull/7362), [pricing implementation](https://github.com/CrocSwap/integer-mult-bounds/blob/c522451caf287bb3c16eaece72be4c263315dca4/research/adjacent-owned-add-exchange-bound/pricing.py) + +This contribution derives the fixed-cut seam condition and independently checks its full single-transposition family and proves a zero ceiling for all simultaneous phase-even permutations. OpenAI Codex and subagents materially assisted the proof, implementation and independent replay. diff --git a/research/p104-type-a-late-mask-permutation-bound/SOURCES.json b/research/p104-type-a-late-mask-permutation-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-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-late-mask-permutation-bound/TASK.json b/research/p104-type-a-late-mask-permutation-bound/TASK.json new file mode 100644 index 0000000000..37b287b776 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113 Type A caller at the cut before event 1741, all 630 unordered root pairs and all 36-root late-mask permutations with a fixed phase-even seam.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 Type A late-mask seam research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "The fixed paid stock can support a small productive gain when a late-mask swap balances two ranks, if the required seam has an ordinary phase-even realization.", + "budget_minutes": 12, + "evidence": "Exact forward and reverse arithmetic exclude all 60 profitable swaps. Signed-prefix invariant classes give an exact zero upper bound on gross productive gain for all fixed phase-even permutations.", + "open_questions": [ + { + "blocked_by": "A phase-even fixed-cut seam has zero optimistic gross allowance. Phase dependence adds a new native and paid obligation.", + "first_step": "Derive the full four-phase action for one profitable permutation and compare its complete price with the fixed comparator before constructing a native lowering.", + "question": "Can a phase-dependent seam or a changed cut earn a positive fully charged saving under comparable premises?", + "why_it_matters": "The complete phase-even permutation family at cut 1741 is excluded at zero seam cost." + } + ], + "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 fixed-cut, exact-source productive-endpoint change and derive a necessary seam condition from the retained caller.", + "scope_status": "changed", + "stop_rule": "One cut, all 630 unordered pairs, 36 basis columns and the two signed phases. Class refinement runs to stability. The all-permutation test stops at a zero price ceiling before any of the 20,000 allowed search branches.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-type-a-late-mask-permutation-bound/VERIFICATION.md b/research/p104-type-a-late-mask-permutation-bound/VERIFICATION.md new file mode 100644 index 0000000000..c0fac28014 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/VERIFICATION.md @@ -0,0 +1,7 @@ +# Verification + +The verification covers all 630 unordered Type A root pairs at one cut. Each signed propagation uses the full 36-dimensional basis with exact rational arithmetic. The forward engine computes a rank-one seam witness with independently reversed inverse events. The reverse engine rebuilds both prefix matrices from covectors and solves the signed commutator relation. Three deterministic JSON receipts give exact pins, per-case decisions and witnesses. The clean wrapper compares both case lists, the 0/9 control, and the physical sign check. It rejects a corrupted caller byte in all five engines. The reverse covector also confirms that omitting the required final output swap breaks the unit-body endpoint. + +The family engines each have a 30-second cap and the one-pair reverse control has a 20-second cap. The one-cut scope is exhausted with zero unresolved profitable cases. The 570 nonprofitable cases need no signed-phase test. No physical seam lowering, combined invoice, complete new supplier or outer application was built or run. The receipts therefore certify a scoped exclusion and do not update the complete bound. + +Two further deterministic receipts independently refine the signed comparison to the same four invariant classes. The exact gross interval is [0,0] and both engines stop before any assignment search. A directed three-cycle control survives refinement while a single swap fails. Both permutation engines have 60-second and 20,000-assignment caps, with zero assignments used. diff --git a/research/p104-type-a-late-mask-permutation-bound/VERIFY.json b/research/p104-type-a-late-mask-permutation-bound/VERIFY.json new file mode 100644 index 0000000000..abd6f07dd0 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Authenticate exact sources, compare signed tests for all 630 single swaps, verify the all-permutation class bound and reject a corrupt caller.", + "timeout_seconds": 230 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-type-a-late-mask-permutation-bound/engines/family_forward.py b/research/p104-type-a-late-mask-permutation-bound/engines/family_forward.py new file mode 100644 index 0000000000..e48de55cde --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/engines/family_forward.py @@ -0,0 +1,123 @@ +"""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"] + 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-late-mask-permutation-bound/engines/family_reverse.py b/research/p104-type-a-late-mask-permutation-bound/engines/family_reverse.py new file mode 100644 index 0000000000..329f9c2938 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/engines/family_reverse.py @@ -0,0 +1,147 @@ +"""Classify all Type A late-mask transpositions at a single fixed cut.""" +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +from itertools import combinations +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/R178-REVERSE.json': 'ad9bbc64a9b866a89f48f1fac0b0346c18105c4b69e62aa41a9cd5575e5c5942', +} +HEAD = 'aaeec8c0acf01e99a5f331ef363a698d9c084ace' +CALLER = '07a76c5e2738882c0cb322278e56f6cae3c9885d' +CUT = 1741 +N = 36 + + +def read(name): + raw = (ROOT / name).read_bytes() + assert sha256(raw).hexdigest() == PINS[name] + return loads(raw) + + +def identity(): + return [[Q(i == j) for j in range(N)] for i in range(N)] + + +def expand(entries): + out = [[Q(0)] * N for _ in range(N)] + for i, j, value in entries: + assert not out[i][j] and Q(value) + out[i][j] = Q(value) + return out + + +def product(left, right): + columns = list(zip(*right, strict=True)) + return [[sum(x*y for x, y in zip(row, col, strict=True) if x and y) + for col in columns] for row in left] + + +def solve(left, right): + augmented = [a + b for a, b in zip(left, right, strict=True)] + for j in range(N): + i = next(i for i in range(j, N) if augmented[i][j]) + augmented[j], augmented[i] = augmented[i], augmented[j] + pivot = augmented[j][j] + augmented[j] = [x/pivot for x in augmented[j]] + for i, row in enumerate(augmented): + if i != j and row[j]: + multiplier = row[j] + augmented[i] = [x - multiplier*y for x, y in zip(row, augmented[j], strict=True)] + assert [row[:N] for row in augmented] == identity() + return [row[N:] for row in augmented] + + +def exchange(i, a, b): + if i == a: + return b + if i == b: + return a + return i + + +def noncommuting_entries(h, a, b): + result = [] + for i in range(N): + for j in range(N): + xh = h[exchange(i, a, b)][j] + hx = h[i][exchange(j, a, b)] + if xh != hx: + result.append([i, j, str(xh), str(hx)]) + return result + + +def timeout(*_): + raise TimeoutError('30-second runner cap') + + +def main(): + assert __debug__ + signal(SIGALRM, timeout) + alarm(30) + c = read('inputs/CALLER.json') + receipt = read('inputs/R178-REVERSE.json') + assert (receipt['benchmark'], receipt['caller'], receipt['cut']) == (HEAD, CALLER, CUT) + assert receipt['pins'] == {'inputs/CALLER.json': PINS['inputs/CALLER.json']} + assert receipt['central_signs'] == [1, -1] and receipt['basis_columns'] == N + tape = c['events'] + assert len(tape) == 4783 and tape[CUT] == ['A', 'ADD', 10, 0, '2'] + for start, end, stages, queries in ((0, CUT, range(1, 9), 4), + (CUT, len(tape), range(9, 18), 0)): + events = tape[start:end] + assert sorted(e[1] for e in events if e[0] == 'J') == list(stages) + assert sum(e[:2] == ['A', 'QUERY'] for e in events) == queries + assert all(set(e[3]) <= set(stages) for e in events if e[:2] == ['A', 'IDLE_ONE']) + d = c['types']['A']['diagonal'] + assert len(d) == N and all(row[:2] == [-1, 0] for row in d) + counts = [(sum(row[2:10]), sum(row[10:])) for row in d] + gp = expand(receipt['prefix_plus']) + gm = expand(receipt['prefix_minus']) + h = solve(gm, gp) + assert product(gm, h) == gp + assert product(h, solve(h, identity())) == identity() + cases = [] + stats = Counter() + for a, b in combinations(range(N), 2): + e_a, l_a = counts[a] + e_b, l_b = counts[b] + old = [1 + 8*(e_a + l_a), 1 + 8*(e_b + l_b)] + new = [1 + 8*(e_a + l_b), 1 + 8*(e_b + l_a)] + assert sum(old) == sum(new) + old_spread = abs(old[0] - old[1]) + new_spread = abs(new[0] - new[1]) + price = ('improves' if new_spread < old_spread else + 'ties' if new_spread == old_spread else 'worsens') + case = {'pair': [a, b], 'old_ranks': old, 'new_ranks': new, + 'old_spread': old_spread, 'new_spread': new_spread, 'price': price} + if price == 'improves': + defects = noncommuting_entries(h, a, b) + case['commuting'] = not defects + case['commutator_nonzeros'] = len(defects) + case['first_commutator_entry'] = defects[0] if defects else None + stats['survivors' if not defects else 'excluded'] += 1 + stats[price] += 1 + cases.append(case) + assert len(cases) == 630 + assert stats['survivors'] + stats['excluded'] == stats['improves'] + predecessor = next(case for case in cases if case['pair'] == [0, 9]) + assert predecessor['old_ranks'] == [137, 9] and predecessor['new_ranks'] == [73, 73] + assert predecessor['price'] == 'improves' and not predecessor['commuting'] + assert not noncommuting_entries(identity(), 0, 9) + alarm(0) + print(dumps({'benchmark': HEAD, 'caller': CALLER, 'cut': CUT, 'pins': PINS, + 'pair_cap': 630, 'runner_cap_seconds': 30, 'central_signs': [1, -1], + 'rank_formula': '1+8*(early+late)', 'statistics': dict(stats), + 'survivors': sorted((case for case in cases if case.get('commuting')), + key=lambda case: (case['new_spread'] - case['old_spread'], + case['pair'])), + 'case_results': cases}, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-type-a-late-mask-permutation-bound/engines/permutation_forward.py b/research/p104-type-a-late-mask-permutation-bound/engines/permutation_forward.py new file mode 100644 index 0000000000..06d56f190c --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/engines/permutation_forward.py @@ -0,0 +1,141 @@ +"""Bound all phase-even late-mask permutations at Type A cut 1741.""" +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from json import dumps, loads +from math import factorial, prod +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +HERE = Path(__file__).resolve().parent +BRANCH_CAP = 20_000 + + +class SearchCap(Exception): + pass + + +def timeout(*_): + raise SearchCap("runner cap") + + +def main(): + assert __debug__ + signal(SIGALRM, timeout) + alarm(60) + forward = run_path(str(HERE / "family_forward.py")) + assert sha256((HERE / "family_forward.py").read_bytes()).hexdigest() == FORWARD_HASH + pins = forward["PINS"] + for name, digest in pins.items(): + assert sha256((HERE / name).read_bytes()).hexdigest() == digest + caller = loads((HERE / "inputs/CALLER.json").read_bytes()) + base = loads((HERE / "inputs/R92-PRICE.json").read_bytes()) + cut, n = forward["CUT"], forward["N"] + tape = caller["events"] + assert tape[cut] == ["A", "ADD", 10, 0, "2"] and len(tape) == 4783 + a = caller["types"]["A"] + assert len(a["ports"]) == 96 and a["roles"] == n + assert all(d[:2] == [-1, 0] for d in a["diagonal"]) + counts = [(sum(d[2:10]), sum(d[10:])) for d in a["diagonal"]] + unit, apply = forward["unit"], forward["apply"] + pre = tape[:cut] + relative = [] + for j in range(n): + v = apply(pre, unit(j), 1) + relative.append(apply(pre, v, -1, inverse=True)) + assert apply(pre, relative[-1], -1) == v + h = [list(row) for row in zip(*relative, strict=True)] + # Every H-automorphism preserves loops and the multiset of directed + # two-edge colours to every already invariant class. + classes = [tuple(range(n))] + rounds = [] + while True: + refined = [] + for group in classes: + buckets = {} + for i in group: + signature = (h[i][i], tuple(tuple(sorted(Counter((h[i][j], h[j][i]) for j in other).items())) + for other in classes)) + buckets.setdefault(signature, []).append(i) + refined.extend(tuple(bucket) for bucket in buckets.values()) + rounds.append(list(map(len, refined))) + if refined == classes: + break + classes = refined + old = [1+8*(x+y) for x,y in counts] + optimistic = [1+8*(x+y) + for group in classes + for x,y in zip(sorted(counts[j][0] for j in group), + sorted((counts[j][1] for j in group), reverse=True), strict=True)] + assert sum(old) == sum(optimistic) + cost = run_path(str(HERE / "inputs/pricing.py"))["cost"] + k = Fraction(base["old_crossing_upper"]) + + def quote(new): + bill = Counter(new) + bill.subtract(old) + return cost(Counter({r: 96*v for r,v in bill.items() if v}), k) + + admissible = prod(factorial(len(g)) for g in classes) + if Counter(old) == Counter(optimistic): + upper = (Fraction(0), Fraction(0)) + else: + upper = quote(optimistic) + assert upper[1] >= 0 + attempts = 0 + full = 0 + best = None + stop = "zero productive gain at class upper" + if upper[1] > 0: + targets = {j: g for g in classes for j in g} + order = sorted(range(n), key=lambda j: (len(targets[j]), j)) + assigned = {} + used = set() + + def visit(depth): + nonlocal attempts, full, best + if depth == n: + full += 1 + ranks = [1+8*(counts[j][0]+counts[assigned[j]][1]) for j in range(n)] + if Counter(ranks) == Counter(old): + return + saving = quote(ranks) + if saving[0] > 0 and (best is None or saving[0] > best[0][0]): + best = (saving, [assigned[j] for j in range(n)], ranks) + return + i = order[depth] + for j in targets[i]: + if j in used: + continue + if attempts == BRANCH_CAP: + raise SearchCap("assignment cap") + attempts += 1 + if h[i][i] != h[j][j]: + continue + if any(h[i][u] != h[j][v] or h[u][i] != h[v][j] for u,v in assigned.items()): + continue + assigned[i] = j + used.add(j) + visit(depth+1) + del assigned[i] + used.remove(j) + + try: + visit(0) + stop = "exhausted" + except SearchCap as err: + stop = str(err) + alarm(0) + print(dumps({"head": base["head"], "caller": base["caller_head"], "cut": cut, + "classes": classes, "round_sizes": rounds, + "class_permutation_upper": admissible, "compatible_optimal_ranks": sorted(optimistic), + "old_ranks": sorted(old), "class_gross": [str(x) for x in upper], + "assignments_visited": attempts, "full_automorphisms": full, "best": best, + "stop": stop, "assignment_cap": BRANCH_CAP, "runner_cap_seconds": 60, + "pins": pins | {"family_forward.py": FORWARD_HASH}}, default=str, indent=2, sort_keys=True)) + + +FORWARD_HASH = "4ad876916978676b47350ad8c88c496a6b8761f52cf4a60b4d2e3595cbba7ffb" +if __name__ == "__main__": + main() diff --git a/research/p104-type-a-late-mask-permutation-bound/engines/permutation_reverse.py b/research/p104-type-a-late-mask-permutation-bound/engines/permutation_reverse.py new file mode 100644 index 0000000000..81c746ec1a --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/engines/permutation_reverse.py @@ -0,0 +1,229 @@ +"""Exact simultaneous color-refinement and optimistic stock price at Type A cut 1741.""" +from collections import Counter, defaultdict +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/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "inputs/r179_replay.py": "720a921b8eb215675bf738c94dac3361592c342fd8f8eeda6d6efb6888061a5a", +} +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +CUT, N, PORTS, CASES, SECONDS = 1741, 36, 96, 20000, 60 + + +def unique(items): + result = dict(items) + assert len(items) == len(result), "duplicate key" + return result + + +def timeout(*_): + raise TimeoutError("60-second cap") + + +def read(path, decode=True): + raw = (ROOT / path).read_bytes() + assert sha256(raw).hexdigest() == PINS[path], path + return loads(raw, object_pairs_hook=unique) if decode else raw + + +def partition(keys): + assigned, colors = {}, [] + for key in keys: + colors.append(assigned.setdefault(key, len(assigned))) + return colors + + +def refine(h): + n = len(h) + colors = partition(h[i][i] for i in range(n)) + history = [colors] + while True: + new = partition((colors[i], tuple(sorted((colors[j], h[i][j], h[j][i]) for j in range(n)))) + for i in range(n)) + if new == colors: + break + assert len(set(new)) > len(set(colors)) + history.append(new) + colors = new + classes = defaultdict(list) + for i, c in enumerate(colors): + classes[c].append(i) + return list(classes.values()), history + + +def rank(e, l): + return 1 + 8*(e+l) + + +def histogram(early, late, perm): + return Counter(rank(e, late[perm[i]]) for i, e in enumerate(early)) + + +def opposite(early, late, classes, assignment=None): + out = dict(assignment or {}) + for group in classes: + left = sorted((i for i in group if i not in out), key=lambda i: (early[i], i)) + right = sorted((j for j in group if j not in out.values()), key=lambda j: (-late[j], j)) + out.update(zip(left, right, strict=True)) + return out + + +def scaled_delta(old, new): + return {r: PORTS*(new[r]-old[r]) for r in sorted(old.keys() | new.keys()) if new[r] != old[r]} + + +def same_h(h, perm): + n = len(h) + return all(h[i][j] == h[perm[i]][perm[j]] for i in range(n) for j in range(n)) + + +def verify_controls(): + # The 3-cycle survives although each individual pair swap fails. + h = [[0, 1, 2], [2, 0, 1], [1, 2, 0]] + classes, _ = refine(h) + assert classes == [[0, 1, 2]] and same_h(h, [1, 2, 0]) + assert not same_h(h, [1, 0, 2]) + early = late = [0, 1, 2] + assert histogram(early, late, opposite(early, late, classes)) == Counter({17: 3}) + broken = [[0, 4, 2], [2, 0, 1], [1, 2, 0]] + assert refine(broken)[0] == [[0], [1], [2]] + return ["directed three-cycle retained", "individual swap rejected", "altered edge separates classes", + "reverse sorting balances ranks"] + + +def search(h, early, late, classes, old, price, progress): + """Case count is one consistent assignment attempted, including singleton placements.""" + assigned = {g[0]: g[0] for g in classes if len(g) == 1} + progress["assignments"] = len(assigned) + seen = set(assigned.values()) + membership = {i: g for g in classes for i in g} + + def visit(): + relaxed = histogram(early, late, opposite(early, late, classes, assigned)) + if relaxed == old: + progress["structurally_zero_branches"] += 1 + return None + delta = scaled_delta(old, relaxed) + if len(assigned) == N: + assert same_h(h, assigned) + progress["exact_automorphisms"] += 1 + interval = price(delta) + if interval[0] > 0: + return {"permutation": [assigned[i] for i in range(N)], "delta": delta, "gain": interval} + progress["nonpositive_or_ambiguous"] += 1 + if interval[1] > 0: + progress["interval_ambiguous"] += 1 + return None + + def choices(i): + return [j for j in membership[i] if j not in seen and + all(h[i][a] == h[j][b] and h[a][i] == h[b][j] for a, b in assigned.items())] + + # Choose minimum domain size, using the role number for ties. + all_choices = [(choices(i), i) for i in range(N) if i not in assigned] + options, i = min(all_choices, key=lambda item: (len(item[0]), item[1])) + if not options: + progress["empty_domain_branches"] += 1 + return None + for j in sorted(options, key=lambda j: (abs(early[i]+late[j]-8), j)): + if progress["assignments"] == CASES: + raise TimeoutError("20,000-assignment cap") + progress["assignments"] += 1 + assigned[i] = j + seen.add(j) + result = visit() + if result is not None: + return result + seen.remove(j) + del assigned[i] + return None + + return visit() + + +def main(): + assert __debug__ + signal(SIGALRM, timeout) + alarm(SECONDS) + report = {"head": HEAD, "caller": CALLER, "cut": CUT, "pins": PINS, "seconds_cap": SECONDS, + "assignments_cap": CASES, "controls": verify_controls(), "capped": False} + try: + c, p, old_price, base = (read(path) for path in ( + "inputs/CALLER.json", "inputs/R178-REVERSE.json", "inputs/R178-PRICE.json", "inputs/R92-PRICE.json")) + for path in ("inputs/pricing.py", "inputs/r179_replay.py"): + read(path, False) + assert (p["benchmark"], p["caller"], p["cut"]) == (HEAD, CALLER, CUT) + assert (old_price["head"], old_price["caller"], old_price["cut"]) == (HEAD, CALLER, CUT) + assert (base["head"], base["caller_head"]) == (HEAD, CALLER) + assert len(c["events"]) == 4783 and c["events"][CUT] == ["A", "ADD", 10, 0, "2"] + a = c["types"]["A"] + assert a["roles"] == len(a["diagonal"]) == N and len(a["ports"]) == PORTS + assert all(row[:2] == [-1, 0] for row in a["diagonal"]) + early, late = [sum(row[2:10]) for row in a["diagonal"]], [sum(row[10:]) for row in a["diagonal"]] + algebra = run_path(str(ROOT / "inputs/r179_replay.py")) + gp, gm = (algebra["expand"](p[key]) for key in ("prefix_plus", "prefix_minus")) + h = algebra["solve"](gm, gp) + assert algebra["product"](gm, h) == gp + assert not algebra["noncommuting_entries"](algebra["identity"](), 0, 9) + assert algebra["noncommuting_entries"](h, 0, 9) + classes, history = refine(h) + old = histogram(early, late, range(N)) + entire = histogram(early, late, opposite(early, late, [list(range(N))])) + best_perm = opposite(early, late, classes) + best = histogram(early, late, best_perm) + delta = scaled_delta(old, best) + assert sum(delta.values()) == sum(r*n for r, n in delta.items()) == 0 + engine = run_path(str(ROOT / "inputs/pricing.py")) + k = Q(base["old_crossing_upper"]) + def price(change): + return engine["cost"](change, k) + assert price(scaled_delta(old, entire))[1] == Q(old_price["whole_reverse_sorted_upper"]) + upper = price(delta) + report.update({"prefix_plus_nonzero": len(p["prefix_plus"]), "prefix_minus_nonzero": len(p["prefix_minus"]), + "h_nonzero": sum(bool(x) for row in h for x in row), "class_history": history, + "classes": [{"roles": group, "early_late": [[early[i], late[i]] for i in group]} + for group in classes], + "old_histogram": old, "relaxed_histogram": best, "relaxed_delta": delta, + "relaxed_permutation": [best_perm[i] for i in range(N)], + "relaxed_upper_interval": upper, + "crossing_upper": str(k), + "price_scope": "96 Type A ports, unchanged paid histogram, zero seam cost", + "search": {"assignments": 0, "structurally_zero_branches": 0, "empty_domain_branches": 0, + "exact_automorphisms": 0, "nonpositive_or_ambiguous": 0, "interval_ambiguous": 0}}) + if old == best: + assert upper == (0, 0) + report["status"] = "uniform zero optimistic gain" + else: + assert upper[1] > 0 + candidate = search(h, early, late, classes, old, price, report["search"]) + report["candidate"] = candidate + report["status"] = "profitable exact signed survivor" if candidate else "exact assignment search exhausted" + if candidate: + 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(candidate["delta"]) + candidate["complete_at_old_crossing_upper"] = price(stock) + candidate["complete_at_original_probe"] = engine["cost"](stock, Q(base["probe"])) + except TimeoutError as exc: + report["capped"] = True + report["status"] = str(exc) + finally: + alarm(0) + print(dumps(report, indent=2, sort_keys=True, default=str)) + if report["capped"]: + raise SystemExit(2) + + +if __name__ == "__main__": + main() diff --git a/research/p104-type-a-late-mask-permutation-bound/engines/seam_reverse.py b/research/p104-type-a-late-mask-permutation-bound/engines/seam_reverse.py new file mode 100644 index 0000000000..f2ee99c8d4 --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-bound/engines/seam_reverse.py @@ -0,0 +1,148 @@ +"""Reverse-covector check of a Type A late-mask reassignment at one seam.""" +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 + +HERE = Path(__file__).resolve().parent +PINS = {"inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc"} +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +CUT = 1741 +ROOTS = (0, 9) +N = 36 + + +def read(name): + raw = (HERE/name).read_bytes() + assert sha256(raw).hexdigest() == PINS[name] + return loads(raw) + + +def basis(index): + return [Q(j == index) for j in range(N)] + + +def swap(row): + a, b = ROOTS + out = row[:] + out[a], out[b] = out[b], out[a] + return out + + +def covector(events, row, q, invert=False): + # If the event product is O_n ... O_1, a row covector acts on it + # from n to 1 and on its inverse from 1 to n. + result = row[:] + direction = -1 if invert else 1 + for event in events if invert else reversed(events): + kind = event[0] + if kind == "B": + continue + if kind == "J": + _, _, (u, v, x, y), _ = event + result[u] += direction*q*result[v] + result[y] -= direction*q*result[x] + continue + assert kind == "A" + _, op, dest, *args = event + if op == "ADD": + src, a = args + result[src] += direction*Q(a)*result[dest] + elif op == "QUERY": + src, exponent = args + assert exponent == -1 + result[src] += direction*q*result[dest] + elif op == "SCALE": + a, = args + result[dest] *= Q(a)**direction + elif op == "SWAP": + src, = args + result[dest], result[src] = result[src], result[dest] + elif op == "IDLE_ONE": + assert args[0] + else: + assert op == "LAMBDA" and args[0] in (1, -1) + return result + + +def nonzero(matrix): + return [[i, j, str(value)] for i, row in enumerate(matrix) + for j, value in enumerate(row) if value] + + +def row_mul(row, matrix): + return [sum(a*b for a, b in zip(row, col, strict=True) if a and b) + for col in zip(*matrix, strict=True)] + + +def stop(*_): + raise TimeoutError("20-second exact seam cap") + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(20) + c = read("inputs/CALLER.json") + assert c["types"]["A"]["roles"] == N + assert c["types"]["A"]["alpha2"] == "-1" + tape = c["events"] + assert len(tape) == 4783 and tape[CUT] == ["A", "ADD", 10, 0, "2"] + pre, post = tape[:CUT], tape[CUT:] + for events, stages, query_count in ((pre, set(range(1, 9)), 4), + (post, set(range(9, 18)), 0)): + assert sorted(event[1] for event in events if event[0] == "J") == sorted(stages) + assert sum(event[:2] == ["A", "QUERY"] for event in events) == query_count + assert all(set(event[3]) <= stages for event in events if event[:2] == ["A", "IDLE_ONE"]) + targets = c["types"]["A"]["diagonal"] + assert len(targets) == N and all(d[:2] == [-1, 0] for d in targets) + masks = [[sum(targets[i][2:10]), sum(targets[i][10:])] for i in ROOTS] + assert masks == [[8, 9], [0, 1]] + + seam, boundary = {}, {} + prefix = {} + + for q in (1, -1): + g = [covector(pre, basis(i), q) for i in range(N)] + prefix[q] = nonzero(g) + + w = [covector(pre, swap(row), q, invert=True) for row in g] + for i, (g_row, w_row) in enumerate(zip(g, w, strict=True)): + assert covector(pre, g_row, q, invert=True) == basis(i) + assert covector(pre, w_row, q) == swap(g_row) + assert row_mul(w_row, w) == basis(i) + after_swap = covector(post, swap(basis(i)), q) + edited = covector(pre, row_mul(after_swap, w), q) + assert edited == [q*x for x in basis(i)] + assert covector(tape, basis(i), q) == edited + seam[q] = w + boundary[q] = { + "displacement_nonzeros": len(nonzero([[x-y for x, y in zip(row, basis(i), strict=True)] + for i, row in enumerate(w)])), + "seam_nonzeros": len(nonzero(w)), + } + + odd = [[a-b for a, b in zip(u, v, strict=True)] + for u, v in zip(seam[1], seam[-1], strict=True)] + witness = nonzero(odd) + # A wrong final readout with no output swap is exposed at unit bodies. + wrong = covector(pre, row_mul(covector(post, basis(ROOTS[0]), 1), seam[1]), 1) + assert wrong != basis(ROOTS[0]) + alarm(0) + print(dumps({ + "benchmark": HEAD, "caller": CALLER, "pins": PINS, "cut": CUT, + "roots": ROOTS, "central_signs": [1, -1], "basis_columns": N, + "early_late_body_counts": masks, "old_ranks": [137, 9], "new_ranks": [73, 73], + "q_even_at_real_pair": not witness, "odd_entries_count": len(witness), + "first_odd_entries": witness[:12], "boundary": boundary, + "seam_plus": nonzero(seam[1]), "seam_minus": nonzero(seam[-1]), + "prefix_plus": prefix[1], "prefix_minus": prefix[-1], + + "runner_cap_seconds": 20, "negative_control": "missing final output swap", + }, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-type-a-late-mask-permutation-bound/inputs/7113-SHA256.json b/research/p104-type-a-late-mask-permutation-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-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-late-mask-permutation-bound/inputs/7113-application.py b/research/p104-type-a-late-mask-permutation-bound/inputs/7113-application.py new file mode 100644 index 0000000000..1a6d358cbe --- /dev/null +++ b/research/p104-type-a-late-mask-permutation-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<