From bb36fc65ee0b161229169505f4840c436c5ca2b9 Mon Sep 17 00:00:00 2001 From: Clear1nsight <22630354+Clear1nsight@users.noreply.github.com> Date: Wed, 11 Nov 2026 14:22:27 +1100 Subject: [PATCH 1/3] Reuse #7147 selected replay navigation for onboarding This is the exact documentation prerequisite retained by #7156. It points the onboarding check to the selected #7000/#7001 review. Credit to Rohan Arun and the source authors. --- docs/ci-verification.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 63ba3e9aa8..52b62d0481 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,8 +1,25 @@ # CI verification -## Current selected-family replay: #6030 +## Current selected-family replay: #7000 with #7001 The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json), +and [explicit source closure](../certificates/frontier7000-source.json). +`make frontier7000-verify` follows that exact-source selected replay. The review +reuses eleven authenticated preceding executions and records seven fresh serial +application, scalar and complete native-catalogue executions. The earlier +monolithic timeout is retained separately and is not completed coverage. +Consult the receipts for exact commands, source heads and limits. + +The five inherited framework assumptions remain. No complete uniform word, +literal multiplier execution, independent human proof or formal-kernel proof +is asserted. Routine research submissions do not need to rerun this +selected-family replay. The sections below preserve historical checkpoints. + +## Historical selected-family replay: #6030 + +The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), and [explicit source closure](../certificates/frontier6030-source.json). From d2e54af81f9dda6487636b79d4964a2385d89b2b Mon Sep 17 00:00:00 2001 From: Clear1nsight <22630354+Clear1nsight@users.noreply.github.com> Date: Wed, 11 Nov 2026 21:53:51 +1100 Subject: [PATCH 2/3] Replay the historical selected check at its inspected commit MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The PR #6292 rejection census and package plan are statements about 2485805. Load its exact sources and planner in a private sparse checkout, keeping all source hashes, 19 expected rejections, nine package selections and the empty-plan control. Subsequent edits to the live Makefile and CI guide no longer invalidate this historical check. The original audit is by unpaidmoon, building on Dennis’s historical replay gate. The pinned repository view follows the precedent of Matarener’s PR #5434. Repair prepared with substantial OpenAI Codex assistance. --- .../historical-selected-replay-gap/README.md | 6 +- .../SOURCES.json | 60 +++++++++--------- .../VERIFY.json | 31 +-------- .../historical-selected-replay-gap/verify.py | 63 ++++++++++++++----- 4 files changed, 82 insertions(+), 78 deletions(-) diff --git a/research/historical-selected-replay-gap/README.md b/research/historical-selected-replay-gap/README.md index 55d8cc3b49..36d9a873ca 100644 --- a/research/historical-selected-replay-gap/README.md +++ b/research/historical-selected-replay-gap/README.md @@ -69,7 +69,11 @@ python3 -B scripts/research_package.py --package research/historical-selected-re The direct command prints `PASS_HISTORICAL_SELECTED_REPLAY_GAP`. A registered replay prints `PASS_REGISTERED_RESEARCH_PACKAGE`. Both require Git history -containing the two inspected commits. +containing the two inspected commits and the source and manifest objects at +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. The verifier uses a temporary +sparse checkout of that commit, checks the declared source digests there, and +uses its planner and manifest inventory. The recorded rejections and selection +therefore remain reproducible after later changes to the live Makefile or CI guide. ## Open next questions diff --git a/research/historical-selected-replay-gap/SOURCES.json b/research/historical-selected-replay-gap/SOURCES.json index c1010eec95..62bb8b3950 100644 --- a/research/historical-selected-replay-gap/SOURCES.json +++ b/research/historical-selected-replay-gap/SOURCES.json @@ -4,13 +4,13 @@ "files": [ { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "0d683a06b9e7ee162496108ce9a7c5d2ee94fccf", "sha256": "4f2d4f2dcd15139ec82658a975f85ed300897385f85799218539f4c8d60567da" }, { "path": "certificates/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "eccafa830c16170c36faf93045ddf1f638f7bcd4", "sha256": "4c0b9d37e1034b2076e30a70f8e514416298c462d9ee98bc87fe6556b14df786" }, @@ -22,7 +22,7 @@ }, { "path": "docs/ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "63ba3e9aa8bdc5e942b56e34244b92b16f854085", "sha256": "c7d3027e9ad8bcbff68f07aa9576b30fb2f3c76c44d876d40c7fdbf4a3e2228a" }, @@ -34,163 +34,163 @@ }, { "path": "research/clifford-state-performance/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "6f98a0061a5104dfab82c9e806f819b41811f684", "sha256": "396d0f08df24952248140d5c65c51b8c902ef1c580892ff7ea182890530f67ee" }, { "path": "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "5e0f92af463ec12c5e1dcc3effd44081a88af647", "sha256": "07a9daeaf2bda308a92e9a4684f13d5fc766c7772d74801fceb7f4599fdab226" }, { "path": "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "9e13266bf85e627f1b7dc225e9530ea69fd2c7f0", "sha256": "421e1211fb1897c45621dc6801c276e53f2e6f335583c9c9049e535f87c0a3b1" }, { "path": "research/community-batch932-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "cc4d03eb59b9ab3f952735f7e88ff18c2d15d7af", "sha256": "184629cac91a5cfaca50330a88596008b824221433867dcf8117539c913c284a" }, { "path": "research/community-batch970-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8b9f4111badf7de5d97684799560b55110e9da79", "sha256": "23188ed920e38a54006cb883e181585620821c63bf7e8b5e05d32719417cc37e" }, { "path": "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "a5300d4e7a5381a3f443fc54c768ca6f0f236d68", "sha256": "3c820fb30e1b4d9bcfc6a7ab524375e5b2abd66b940af2c509146104f0bcd79c" }, { "path": "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "d7ff6d777b01d69b6ce84caf25d3b7e4a4d2f211", "sha256": "6b185a9902652f893f3ebd8ada92d2f11b6de6533a9a4d11718a8a4496101128" }, { "path": "research/community-hyperplane599-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "546f37d326d10a99910ae8f908e71ef768524d98", "sha256": "65099d764bfcc39bda5e4d9966783611b094c3522dbdd1435cd498d657a8ef8e" }, { "path": "research/community-k492-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "e538481e4cb16ed936d3195f2dfb5b5a9ca0a76b", "sha256": "2c0f4fa5bc150d05658af2e7c54c4d2c337dd52b7efd3d69530ae73bcbdf452a" }, { "path": "research/community-reconciliation92-audit/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "2a2e93685173d5f13cbb5abe740f5d90352e0228", "sha256": "5f501f3c118131e7d069f30ad77186eb2ad6961f9680a0ef105f4514ed41808a" }, { "path": "research/partial-swap-digest/baseline.py", - "usage": "input", + "usage": "provenance", "git_blob": "a2f0190704db83bd8ef48e46e723c49b925804fe", "sha256": "81e9af92cdf38243a540cdcff2062778e449467848d444da37a9553c12ca4c34" }, { "path": "research/r420-two-sided-basis/SOURCES.json", - "usage": "input", + "usage": "provenance", "git_blob": "5d718e11e62f4bcadecf1e02d6b61f87dbe190b0", "sha256": "d9810b0d139c5a1211fd2c1f0d142187cc1fca30026e1e7bc4f9ecfacf1596d1" }, { "path": "research/skip-clones/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", "sha256": "0b68e63e35a97ce6b0cdb6e291b88ebaa8f2dd4afb70b2498f10ee89428258dc" }, { "path": "research/split-skip/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", "sha256": "7c2b4646a3ecfef6f881da5c43e4bd0fa9a4d1b00548b8ab458d897e16735134" }, { "path": "scripts/historical-ci-inputs/Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "aff68409021c9d401a6f8013b9dfd7dbcc30f2a8", "sha256": "ea8830dd79da493e2d75baf753d733ff7efbcf2b4794afe41fae0ac8f3055646" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "65db599ab0b1dea0312c4ca048e0bd0f44c3736f", "sha256": "96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "34820a8f24678f918f4d0e7a35380d8013fc3495", "sha256": "628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac" }, { "path": "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "c755b76e0d44ba4917aa94440ebe54daefce5b2a", "sha256": "d7fd929726b326aeeaf0a3996475adec88eee9aac09ae0bebeeaa0bc1fc8f199" }, { "path": "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "7f3c012504187917a728b9fe87043f0fc8cd006a", "sha256": "a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0" }, { "path": "scripts/historical-ci-inputs/partial-swap-context.json", - "usage": "input", + "usage": "provenance", "git_blob": "ad65114886bf34a4fd27e79f3be502389e689faa", "sha256": "833a9642f33aeab2ffea17ec9c6b82e0a953f90192b2c82e10bef21538dccba9" }, { "path": "scripts/historical-ci-inputs/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "52075f2463f60af5e16571347f24274fce73a1ea", "sha256": "f3c4be597b2f2136da4ae2cc80c7454f63c90aa01f84e5b8131cee4dd55de815" }, { "path": "scripts/partial_swap/shared.py", - "usage": "input", + "usage": "provenance", "git_blob": "44a0e454c70f9c4b98e258b8443612e6a119904b", "sha256": "5a0646a50b9f3e8ea55168620a78e8853b0ab810517cefc8cfb8696aedee278a" }, { "path": "scripts/replay_historical_check.py", - "usage": "input", + "usage": "provenance", "git_blob": "1e92fff2782970ef71378f594f2350d245a4db26", "sha256": "5467619c78183d3adc82b0cb55af28e5c1a01fca2b0588677816244b53e2bafd" }, { "path": "scripts/research_package.py", - "usage": "input", + "usage": "provenance", "git_blob": "091b4c8f58bac9a9580d76025b887dc5c873d05f", "sha256": "e1256016e7f51827d04fa2179255989f639ae1d97afaa9c16265f85a0c6abd70" }, { "path": "scripts/run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "a96ab35b315ce492e7fbbfd6c5ae211aa066b541", "sha256": "49eb56dd0fc0d8d8ffdb209970a7adf2176223580646f575d5c22e59543b381c" }, { "path": "scripts/verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "6882a4700e410dec569b51ae2eaf1a19cc019195", "sha256": "d6b305eac5b9bdb8172c469ad30a1655a60fa0aceac8b1bf610e1b73f51babd8" }, { "path": "tests/test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "343b24abf6719b81805eba5a84c74e57634c8288", "sha256": "3a5470d0b139828b90e19bf9583ddeafcd69f8e34f2824664eb3a2958a52e34d" } diff --git a/research/historical-selected-replay-gap/VERIFY.json b/research/historical-selected-replay-gap/VERIFY.json index 98553e72ed..ab7efa3471 100644 --- a/research/historical-selected-replay-gap/VERIFY.json +++ b/research/historical-selected-replay-gap/VERIFY.json @@ -4,36 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "Makefile", - "certificates/partial-swap-network.json", - "docs/ci-verification.md", - "research/clifford-state-performance/SOURCE.json", - "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "research/community-batch932-audit/CONTENT-COVERAGE.json", - "research/community-batch970-audit/CONTENT-COVERAGE.json", - "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "research/community-hyperplane599-audit/SOURCE.json", - "research/community-k492-audit/SOURCE.json", - "research/community-reconciliation92-audit/MANIFEST.json", - "research/partial-swap-digest/baseline.py", - "research/r420-two-sided-basis/SOURCES.json", - "research/skip-clones/SOURCE.json", - "research/split-skip/SOURCE.json", - "scripts/historical-ci-inputs/Makefile", - "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "scripts/historical-ci-inputs/partial-swap-context.json", - "scripts/historical-ci-inputs/partial-swap-network.json", - "scripts/partial_swap/shared.py", - "scripts/replay_historical_check.py", - "scripts/research_package.py", - "scripts/run_isolated_tests.py", - "scripts/verify_selected_result.py", - "tests/test_isolated_test_runner.py" + "scripts/research_package.py" ], "commands": [ { diff --git a/research/historical-selected-replay-gap/verify.py b/research/historical-selected-replay-gap/verify.py index 83b995941a..9d266c5a4e 100644 --- a/research/historical-selected-replay-gap/verify.py +++ b/research/historical-selected-replay-gap/verify.py @@ -6,8 +6,10 @@ """ import hashlib import importlib.util +import json import subprocess import sys +import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[2] @@ -61,31 +63,47 @@ def require(ok, message): raise SystemExit(message) -def load_checker(): - path = ROOT / "scripts/replay_historical_check.py" - spec = importlib.util.spec_from_file_location("historical_selected_replay_gap_checker", path) +def load_module(path): + spec = importlib.util.spec_from_file_location(path.stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module +def checkout_snapshot(snapshot, sources, runner, env): + paths = [runner.canonical_relative_path(row["path"]) for row in sources["files"]] + git = ["git", "-c", "maintenance.auto=false", "-c", "gc.auto=0", + "-c", "core.autocrlf=false"] + subprocess.run([*git, "clone", "--quiet", "--shared", "--no-tags", "--no-checkout", + "--", str(ROOT), str(snapshot)], cwd=ROOT, env=env, check=True) + subprocess.run([*git, "update-ref", "--no-deref", "HEAD", INSPECTED], + cwd=snapshot, env=env, check=True) + # The pinned planner reads omitted manifests from the sparse HEAD/index. + patterns = "".join(f"/{path.as_posix()}\n" for path in paths) + subprocess.run([*git, "sparse-checkout", "set", "--no-cone", "--stdin"], + cwd=snapshot, env=env, input=patterns.encode("utf-8"), check=True) + subprocess.run([*git, "read-tree", "-mu", "HEAD"], cwd=snapshot, env=env, check=True) + for path, row in zip(paths, sources["files"], strict=True): + require(hashlib.sha256((snapshot / path).read_bytes()).hexdigest() == row["sha256"], + "historical checkout source digest changed: " + path.as_posix()) + + def entries(checker): for name, config in checker.CONFIG.items(): for entry in [config, *config.get("additional_inputs", [])]: yield name, entry -def reject(checker, entry): +def reject(root, checker, entry): try: - checker.authenticated_input(ROOT, entry) + checker.authenticated_input(root, entry) except ValueError as exc: return str(exc) raise SystemExit("historical input was admitted: " + entry["path"]) -def main(): - require(not sys.flags.optimize, "assertions must stay enabled") - checker = load_checker() +def check_snapshot(root, env): + checker = load_module(root / "scripts/replay_historical_check.py") selected = [entry for name, entry in entries(checker) if name == "tooling-ledger" and entry["path"] == SELECTED_PATH] require(len(selected) == 1, "selected-result checker overlay is not unique") @@ -94,7 +112,7 @@ def main(): require(entry["accepted_live_sha256"] == [SELECTED_ACCEPTED], "accepted selected-checker successors changed") frozen = (checker.INPUTS / entry["input"]).read_bytes() - live = (ROOT / SELECTED_PATH).read_bytes() + live = (root / SELECTED_PATH).read_bytes() require(hashlib.sha256(frozen).hexdigest() == SELECTED_PIN, "frozen selected checker bytes changed") require(hashlib.sha256(live).hexdigest() == SELECTED_LIVE, "live selected checker digest changed") require(SELECTED_LIVE not in (SELECTED_PIN, SELECTED_ACCEPTED), "live checker was already admitted") @@ -102,7 +120,7 @@ def main(): # live successor, not a broken comparison. require(SELECTED_PIN in (SELECTED_PIN, *entry["accepted_live_sha256"]), "pin membership control failed") - require(reject(checker, entry) == REJECTIONS[SELECTED_PATH][1], + require(reject(root, checker, entry) == REJECTIONS[SELECTED_PATH][1], "selected checker rejection text changed") counts = {path: 0 for path in REJECTIONS} @@ -110,7 +128,7 @@ def main(): for _name, item in entries(checker): if item["path"] not in REJECTIONS: continue - message = reject(checker, item) + message = reject(root, checker, item) counts[item["path"]] += 1 messages.setdefault(item["path"], message) for path, (count, message) in REJECTIONS.items(): @@ -118,20 +136,31 @@ def main(): require(messages[path] == message, "rejection text changed for " + path) require(sum(counts.values()) == 19, "rejection total changed") ci = [item for _name, item in entries(checker) if item["path"] == CI_PATH] - require(len(ci) == 1 and hashlib.sha256((ROOT / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, + require(len(ci) == 1 and hashlib.sha256((root / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, "selected CI note digest changed") diff = subprocess.check_output( - ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=ROOT, text=True) + ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=root, env=env, text=True) changed = sorted(name for name in diff.splitlines() if name) require(changed == CHANGED, "inspected commit diff changed") - sys.path.insert(0, str(ROOT / "scripts")) - from research_package import plan_details - details = plan_details(ROOT, set(changed)) + planner = load_module(root / "scripts/research_package.py") + details = planner.plan_details(root, set(changed)) require([row["package"] for row in details] == PLAN_PACKAGES, "helper plan selection changed") matched = {name for row in details for names in row["causes"].values() for name in names} require(sorted(set(changed) - matched) == UNMATCHED, "unmatched plan paths changed") - require(plan_details(ROOT, set()) == [], "empty change set selected a package") + require(planner.plan_details(root, set()) == [], "empty change set selected a package") + + +def main(): + require(not sys.flags.optimize, "assertions must stay enabled") + sources = json.loads(Path(__file__).with_name("SOURCES.json").read_bytes()) + require(sources["base_commit"] == INSPECTED, "historical checkout base changed") + runner = load_module(ROOT / "scripts/research_package.py") + env = runner.git_source_env() + with tempfile.TemporaryDirectory(prefix="historical-selected-replay-") as temporary: + snapshot = Path(temporary) / "snapshot" + checkout_snapshot(snapshot, sources, runner, env) + check_snapshot(snapshot, env) print("PASS_HISTORICAL_SELECTED_REPLAY_GAP") print("selected_checker_live=" + SELECTED_LIVE) print("rejections=19 distinct_paths=7 plan_packages=9") From 3d1a62e154957f00aeeb4eec703cf6a07dfa3ef0 Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Thu, 12 Nov 2026 05:35:32 -0800 Subject: [PATCH 3/3] Bound four-factor reuse of signed Type A phase legs --- .../LOCAL-PINS.json | 15 + .../NOTICE | 3 + .../PROOF.md | 27 + .../PROVENANCE.json | 89 + .../README.md | 17 + .../SOURCES.json | 18 + .../TASK.json | 117 + .../VERIFICATION.md | 7 + .../VERIFY.json | 19 + .../engines/forward.py | 125 + .../engines/independent.py | 227 + .../engines/lead.py | 149 + .../engines/rank_gate.py | 56 + .../inputs/7113-SHA256.json | 69 + .../inputs/7113-signed-child.py | 146 + .../inputs/CALLER.json | 1 + .../inputs/R193.json | 2778 + .../inputs/R194.json | 1131 + .../inputs/R195.json | 9287 +++ .../receipts/INDEPENDENT.json | 55089 ++++++++++++++++ .../receipts/LEAD-PINS.txt | 4 + .../receipts/LEAD.json | 50023 ++++++++++++++ .../replay.py | 102 + 23 files changed, 119499 insertions(+) create mode 100644 research/p104-signed-phase-leg-four-factor-bound/LOCAL-PINS.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/NOTICE create mode 100644 research/p104-signed-phase-leg-four-factor-bound/PROOF.md create mode 100644 research/p104-signed-phase-leg-four-factor-bound/PROVENANCE.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/README.md create mode 100644 research/p104-signed-phase-leg-four-factor-bound/SOURCES.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/TASK.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/VERIFICATION.md create mode 100644 research/p104-signed-phase-leg-four-factor-bound/VERIFY.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/engines/forward.py create mode 100644 research/p104-signed-phase-leg-four-factor-bound/engines/independent.py create mode 100644 research/p104-signed-phase-leg-four-factor-bound/engines/lead.py create mode 100644 research/p104-signed-phase-leg-four-factor-bound/engines/rank_gate.py create mode 100644 research/p104-signed-phase-leg-four-factor-bound/inputs/7113-SHA256.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/inputs/7113-signed-child.py create mode 100644 research/p104-signed-phase-leg-four-factor-bound/inputs/CALLER.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/inputs/R193.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/inputs/R194.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/inputs/R195.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/receipts/INDEPENDENT.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/receipts/LEAD-PINS.txt create mode 100644 research/p104-signed-phase-leg-four-factor-bound/receipts/LEAD.json create mode 100644 research/p104-signed-phase-leg-four-factor-bound/replay.py diff --git a/research/p104-signed-phase-leg-four-factor-bound/LOCAL-PINS.json b/research/p104-signed-phase-leg-four-factor-bound/LOCAL-PINS.json new file mode 100644 index 0000000000..f7e2e48790 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/LOCAL-PINS.json @@ -0,0 +1,15 @@ +{ + "engines/forward.py": "75d94780f9db49a4b08bb0e7fb4bd7fc04adb8cabbf73d83a809179c04c3d439", + "engines/independent.py": "fa8c2394180661395595cab1204bddd56d2120255fbf566dabff1ed695448f34", + "engines/lead.py": "f1dd6b9d2dbba8316b785a6dc78c9e3690b1af28f59f17861f9dc73750703926", + "engines/rank_gate.py": "c5828f686452a908c2bfadb9ba407ccc94efb4e8c533ab814b8c7dd0a26a34e0", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/R193.json": "4926019203f511866cf327128ebcd291561ebc03b6d77a6816361d7128d4664c", + "inputs/R194.json": "49b7dbd3d08c56b16dc43f23bd6f410dde0b98040d922cee6f617786eb474834", + "inputs/R195.json": "f6091c7c63b21145077808bbdacc61431f641d0da37f9fa648aea4b7ead3b472", + "receipts/INDEPENDENT.json": "95d3c16e4c80ff043ef6bd529d3ea04c135943fc8f4d196bcb10dee78491ebd2", + "receipts/LEAD-PINS.txt": "e1846ccfeb5f3fb1f2d4a8e6d649f91f8a81a5dcba9e28e1bb33b56ccb173fb5", + "receipts/LEAD.json": "a865387c37699caf55f9b364d9879fb74e77b6e69ae4fbe68311ad9382477d4e" +} diff --git a/research/p104-signed-phase-leg-four-factor-bound/NOTICE b/research/p104-signed-phase-leg-four-factor-bound/NOTICE new file mode 100644 index 0000000000..b13e01f706 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/NOTICE @@ -0,0 +1,3 @@ +Apache-2.0. + +#7334 supplies the complete independently reproduced comparator and #7113 the exact Type A caller and physical Gaussian factors. #7419 supplies the exact proper-window ranks, price and reusable exact prefix and rank code. #7420 supplies the exact 38-factor relative word and separate pair/triple results. OpenAI Codex and subagents materially assisted proof, implementation, replay and packaging. diff --git a/research/p104-signed-phase-leg-four-factor-bound/PROOF.md b/research/p104-signed-phase-leg-four-factor-bound/PROOF.md new file mode 100644 index 0000000000..e2ddebd3e1 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/PROOF.md @@ -0,0 +1,27 @@ +# Exact fixed relative factors + +Fix the complete signed #7334/#7113 comparator, the 36-role Type A caller, unit body factors and the two legal central values q=+1 and q=−1. The literal binary Gaussian factor has eigenvalues 1 and i on (1,1) and (1,−1). Unit bodies come from all-plus Walsh factors. Two central minus factors at an admitted width give −1, and all plus gives +1. The two central sectors agree on ordinary q² work. + +Let G_+(t) and G_−(t) be the literal signed Type A prefixes through pre-event cut t and write H(t)=G_−(t) inverse times G_+(t). Each J contributes two rank-one relative factors and each original A QUERY contributes one. All other normalized factors agree at the two signs. The 17 J calls and four QUERYs give the exact chronological 38-factor word. Each factor is I+u v^T with v^T u=0. Both implementations reconstruct the word from the literal caller and check the full relative product −I on all 36 basis columns. Factor labels are matched to the exact #7420 receipts. + +## Scope reduced by proper windows + +For any interval from pre-event cuts a to b, the sign-difference rank equals rank(H(b)−H(a)). It therefore equals the displacement rank of the relative product for that interval, H(b) times H(a) inverse. The exact #7419 proper-window receipt verifies that each of the 152 proper maximal anchored windows has rank equal to the total number of old relative factors in that window. + +Select any four old factors within a proper window. Collect them by transporting each through only the later unselected factors. The old product becomes the product of the transported selected factors and the unchanged product of the unselected ones. Rank subadditivity for the displacement of a product gives an upper bound equal to the sum of those displacements. If the four-factor displacement had rank at most three, the total window would have rank at most three plus its number of unselected factors. That contradicts the authenticated full window rank. This covers all four-sets that omit J1 or J17. A proper window can retain surrounding old QUERYs within its fixed anchors. + +There are 73,815 four-sets of 38 factors. Of these, 2,381 contain at least one of the two factors at J1 and at least one of the two at J17. The explicit census covers exactly those 2,381 and the proper-window argument covers the other 71,434. + +## Explicit rank-four proof + +For each selected factor, conjugate it by the chronological product of the later unselected factors before the final selected index. If one such intervening factor is I+x y^T, the transported pair changes by u→u+x(y^T u) and v→v−y(v^T x). The equality y^T x=0 makes the inverse exact. All selected factors retain their chronological order. + +For transported pairs (u_j,v_j), the selected product minus identity equals U R. The columns of U are u_j. The j-th row of R equals v_j^T plus a combination of earlier rows with coefficients v_j^T u_i. This unit triangular change preserves the row rank of the transported V. Rank four of both U and V therefore proves rank four of the product displacement. Any product of three rank-one differences has displacement rank at most three, even with arbitrary intervening fixed factors handled by the same transport. + +The lead rank calculation uses prime 65521, with every original rational denominator checked invertible modulo that prime. Conjugation and transport use only addition and multiplication, so their denominators remain invertible. Nonzero modular rank-four minors prove nonzero rational minors. The independent calculation instead maintains exact prefix rows and inverse columns, clears denominators, transports integer representatives up to nonzero scale, and calculates exact nonzero integer minors for each U and V. Both checks prove rank four for every explicit case. The first case [0,1,2,36] uses coordinates [0,1,2,18] on both sides and scaled integer determinants 6 and 1. The receipts give the full case scope and pivots. The fallback exact product calculations are available if either sufficient test fails. No fallback or three-factor construction was triggered. + +## Price context and limits + +The previously scoped one-saved-leg motivating replacement would retire one native call with its helper targets, add 400 direct rank-eight bodies and 112 rank-one calls, and retain the other original occurrences. Its inherited directed optimistic quote at the incumbent is about 50.33412118538 raw. The four-factor rank obstruction stops this fixed catalogue before physical lowering. It grants arbitrary rational rank-one replacement factors and leaves changed surrounding factors, larger groups, different physical fields and new pricing premises open. + +No native rewrite, tape restoration check for a modified word, or recurrence improvement followed. The evidence establishes the fixed rational obstruction. diff --git a/research/p104-signed-phase-leg-four-factor-bound/PROVENANCE.json b/research/p104-signed-phase-leg-four-factor-bound/PROVENANCE.json new file mode 100644 index 0000000000..45e4ab8386 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/PROVENANCE.json @@ -0,0 +1,89 @@ +{ + "ai_assistance": "OpenAI Codex and subagents materially assisted.", + "files": { + "engines/forward.py": { + "commit": "a590edb3c5f7efd7404b1203e727c8cc3218493e", + "git_blob": "7842fd300e9aa30ea65a8526c92f761b7ea876b0", + "path": "research/p104-contiguous-direct-j-replacement-bound/engines/forward.py", + "sha256": "75d94780f9db49a4b08bb0e7fb4bd7fc04adb8cabbf73d83a809179c04c3d439", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a590edb3c5f7efd7404b1203e727c8cc3218493e/research/p104-contiguous-direct-j-replacement-bound/engines/forward.py" + }, + "engines/rank_gate.py": { + "commit": "a590edb3c5f7efd7404b1203e727c8cc3218493e", + "git_blob": "8ed714b15c5c49611931b04582d82415387a9cc9", + "path": "research/p104-contiguous-direct-j-replacement-bound/engines/rank_gate.py", + "sha256": "c5828f686452a908c2bfadb9ba407ccc94efb4e8c533ab814b8c7dd0a26a34e0", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a590edb3c5f7efd7404b1203e727c8cc3218493e/research/p104-contiguous-direct-j-replacement-bound/engines/rank_gate.py" + }, + "inputs/7113-SHA256.json": { + "commit": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "git_blob": "5a7d6b80dc51aa918a5d521b60d18f9a6bbbc52e", + "path": "research/signed-caller-8x9/SHA256.json", + "sha256": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "source": "https://github.com/rohanarun/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/SHA256.json" + }, + "inputs/7113-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/R193.json": { + "commit": "a590edb3c5f7efd7404b1203e727c8cc3218493e", + "git_blob": "d2f272917b1279849701bc25d04580b73a479498", + "path": "research/p104-contiguous-direct-j-replacement-bound/receipts/R193-LEAD.json", + "sha256": "4926019203f511866cf327128ebcd291561ebc03b6d77a6816361d7128d4664c", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a590edb3c5f7efd7404b1203e727c8cc3218493e/research/p104-contiguous-direct-j-replacement-bound/receipts/R193-LEAD.json" + }, + "inputs/R194.json": { + "commit": "a9809ce276aca6859e140404626c8772870215f2", + "git_blob": "53bb4c9b0cde9db92acd8261f6b9d2d9874a9319", + "path": "research/p104-signed-phase-leg-reuse-bound/receipts/R194-REVERSE.json", + "sha256": "49b7dbd3d08c56b16dc43f23bd6f410dde0b98040d922cee6f617786eb474834", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a9809ce276aca6859e140404626c8772870215f2/research/p104-signed-phase-leg-reuse-bound/receipts/R194-REVERSE.json" + }, + "inputs/R195.json": { + "commit": "a9809ce276aca6859e140404626c8772870215f2", + "git_blob": "5a681a34ff6836d5830df4d2c51887e58cda9c13", + "path": "research/p104-signed-phase-leg-reuse-bound/receipts/R195-REVERSE.json", + "sha256": "f6091c7c63b21145077808bbdacc61431f641d0da37f9fa648aea4b7ead3b472", + "source": "https://github.com/CrocSwap/integer-mult-bounds/blob/a9809ce276aca6859e140404626c8772870215f2/research/p104-signed-phase-leg-reuse-bound/receipts/R195-REVERSE.json" + } + }, + "overlap": "Fresh exact public overlap check preceded the R202 runner. The earlier exact phase-leg contribution covers selected pairs and triples. This package checks four-factor groups on the same frozen caller and keeps all unselected factors fixed.", + "predecessors": [ + { + "contribution": "Exact complete comparator and paid/target context.", + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "pull_request": 7334, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334" + }, + { + "contribution": "Literal signed Type A caller and physical Gaussian factors.", + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "pull_request": 7113, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7113" + }, + { + "contribution": "All exact proper-window ranks and motivating directed price. The lead reuses the exact forward/rank engines.", + "head": "a590edb3c5f7efd7404b1203e727c8cc3218493e", + "pull_request": 7419, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7419" + }, + { + "contribution": "Exact original 38-factor relative word and fixed pair/triple certificates.", + "head": "a9809ce276aca6859e140404626c8772870215f2", + "pull_request": 7420, + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7420" + } + ], + "schema_version": 1 +} diff --git a/research/p104-signed-phase-leg-four-factor-bound/README.md b/research/p104-signed-phase-leg-four-factor-bound/README.md new file mode 100644 index 0000000000..96c20a8812 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/README.md @@ -0,0 +1,17 @@ +# Four-factor reuse of signed Type A phase legs + +**NO VERIFIED GAIN.** This package extends [#7420's pair and triple tests](https://github.com/CrocSwap/integer-mult-bounds/pull/7420) to four factors on the exact 38-factor Type A relative word from [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113). The independently reproduced complete comparator is [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) with #7113, κ = 0.00364665195644. + +The [#7419 proper-window ranks](https://github.com/CrocSwap/integer-mult-bounds/pull/7419) rule out every four-set contained in a proper anchored window. Both exact methods check the 2,381 other four-sets, which meet J1 and J17. Every selected product has displacement rank four after transport past the unchanged intervening factors. Three rank-one changes cannot supply that displacement. All cases are resolved. Realized saving and Δκ are zero. [Proof](PROOF.md). + +From a clean POSIX checkout with CPython 3.12 and assertions: + +```sh +python3.12 -I -B research/p104-signed-phase-leg-four-factor-bound/replay.py +``` + +The replay authenticates the literal caller and exact predecessors, regenerates the denominator-safe modular certificates and independent integer minors, and rejects a corrupted caller. [Verification and sources](VERIFICATION.md). + +## Open next questions + +Can a changed factor group or a different signed provider lower the exact displacement and whole paid invoice? Pin one such change and price every new field and adapter before checking its signed action. Larger groups and edits to the unselected factors remain open. diff --git a/research/p104-signed-phase-leg-four-factor-bound/SOURCES.json b/research/p104-signed-phase-leg-four-factor-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-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-signed-phase-leg-four-factor-bound/TASK.json b/research/p104-signed-phase-leg-four-factor-bound/TASK.json new file mode 100644 index 0000000000..a72e8d3e87 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "On exact #7334 with #7113 signed caller, keep the fixed 38 chronological relative rank-one factors at unit bodies and legal q=\u00b11. Select four original factors, transport them past only unselected intervening factors, and test the rank of their product minus identity. Authenticate #7419 proper windows and explicitly check all 2,381 four-sets crossing both extreme J hosts.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 signed Type A four-factor rank research", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "Reducing four selected rank-one relative legs to three requires displacement rank at most three. In the motivating fixed-paid caller family, removal of a signed query channel could improve the binding raw cost, subject to a full native and physical supplier proof.", + "budget_minutes": 8, + "evidence": "Two separate exact methods reconstruct the relative sequence and verify all 2,381 endpoint-crossing sets have rank four. The #7419 full-rank proper windows exclude every other four-set by rank subadditivity. Exact minors and denominator-safe modular pivots are replayable. No survivor, unresolved case, changed native construction or gain.", + "open_questions": [ + { + "blocked_by": "The closed scope preserves every unselected factor. Larger selected groups or changed phases, fields, adapters or provider contracts need a separate price and exact action.", + "first_step": "Pin one exact changed factor group and the complete paid and target changes. Compare the transported displacement rank on legal opposite signs before any physical lowering.", + "question": "Could a changed factor set or a different signed supplier produce a lower-rank displacement?", + "why_it_matters": "The fixed four-factor catalogue cannot save a single relative rank-one leg. A different factor set could change the rank and invoice." + } + ], + "original_card": { + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "existing_checks": [ + { + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4133: literal-slot defect", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4136: uniform commutation gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4140: uniform encoding gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "status": "author-checked" + }, + { + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "status": "author-checked" + }, + { + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4154: fiber-tag seam mismatch", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "status": "author-checked" + }, + { + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "status": "reviewed" + } + ], + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "id": "p104-side-correction", + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "Extend the exact fixed pair and triple Type A relative phase-leg tests to all four-factor choices.", + "scope_status": "changed", + "stop_rule": "Authenticate the fixed 38-factor tape and proper windows, then exhaust 2,381 endpoint-crossing four-sets within 45 seconds per method. Advance at most one rank-at-most-three survivor to a separately capped three-factor algebra check.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-signed-phase-leg-four-factor-bound/VERIFICATION.md b/research/p104-signed-phase-leg-four-factor-bound/VERIFICATION.md new file mode 100644 index 0000000000..6959f5566e --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/VERIFICATION.md @@ -0,0 +1,7 @@ +# Verification + +The exact public #7419 proper-window receipt and #7420 pair/triple receipts are included byte-for-byte. The replay authenticates all sources by relative path and checks the physical binary Gaussian eigenvectors. Both engines reconstruct the literal 38-factor relative word and check the old endpoint on all 36 basis columns. + +The lead authenticates every rational denominator before computing ranks over the prime field. The independent engine uses exact fraction-free integer rank checks and verifies two nonzero 4×4 minors for every endpoint-crossing key. Both have a 45-second cap and an exact rational full-product fallback. The wrapper matches all 2,381 keys, certified ranks and exhaustion states. A separate mutation changes the actual J1 host in a disposable caller copy. The real independent replay rejects the changed caller. + +Original lead runner time was 2.49s and independent time 1.17s. Both scopes exhausted with zero unresolved cases. The relocated independent replay produced the same receipt. CPython 3.12 on POSIX, assertions and the standard library suffice. Exact source commits, paths, hashes and predecessor credit are in [PROVENANCE.json](PROVENANCE.json). diff --git a/research/p104-signed-phase-leg-four-factor-bound/VERIFY.json b/research/p104-signed-phase-leg-four-factor-bound/VERIFY.json new file mode 100644 index 0000000000..320dd5f0b7 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Regenerate the exact integer-minor and denominator-safe modular rank receipts for all 2,381 cases. Confirm the physical phase specialization, match the rank results and reject a corrupted original J host.", + "timeout_seconds": 130 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-signed-phase-leg-four-factor-bound/engines/forward.py b/research/p104-signed-phase-leg-four-factor-bound/engines/forward.py new file mode 100644 index 0000000000..7842fd300e --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/engines/forward.py @@ -0,0 +1,125 @@ +"""Check profitable Type A late-mask swaps by direct forward propagation.""" +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +from itertools import combinations +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +HERE = Path(__file__).resolve().parent +N = 36 +CUT = 1741 +PINS = { + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/R92-PRICE.json": "05d7a5ebdd2eeedd6c8f534e8e2eeac22484daf9f387f4a6b88cc9eed22a6b8f", + "inputs/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} + + +def unit(i): + return [Fraction(i == j) for j in range(N)] + + +def apply(events, column, q, inverse=False): + col = column.copy() + direction = -1 if inverse else 1 + for event in reversed(events) if inverse else events: + if event[0] == "B": + continue + if event[0] == "J": + _, _, (u, v, x, y), _ = event + assert len({u, v, x, y}) == 4 + col[v] += direction * q * col[u] + col[x] -= direction * q * col[y] + continue + assert event[0] == "A" + _, op, dest, *args = event + if op == "ADD": + src, value = args + col[dest] += direction * Fraction(value) * col[src] + elif op == "QUERY": + src, exponent = args + assert exponent == -1 + col[dest] += direction * q * col[src] + elif op == "SWAP": + src, = args + col[dest], col[src] = col[src], col[dest] + elif op == "SCALE": + value, = args + col[dest] *= Fraction(value) ** direction + else: + assert op in ("IDLE_ONE", "LAMBDA") + return col + + +def stop(*_): + raise TimeoutError("30-second solver cap") + + +def main(): + assert __debug__ + signal(SIGALRM, stop) + alarm(30) + for name, digest in PINS.items(): + assert sha256((HERE / name).read_bytes()).hexdigest() == digest + caller = loads((HERE / "inputs/CALLER.json").read_bytes()) + old = loads((HERE / "inputs/R92-PRICE.json").read_bytes()) + tape = caller["events"] + a = caller["types"]["A"] + assert len(a["ports"]) == 96 and a["roles"] == N and len(tape) == 4783 + assert tape[CUT] == ["A", "ADD", 10, 0, "2"] + assert all(row[:2] == [-1, 0] for row in a["diagonal"]) + counts = [(sum(row[2:10]), sum(row[10:])) for row in a["diagonal"]] + pre = tape[:CUT] + forward, inverse = {}, {} + for q in (1, -1): + forward[q] = [apply(pre, unit(i), q) for i in range(N)] + inverse[q] = [apply(pre, unit(i), q, inverse=True) for i in range(N)] + for i in range(N): + assert apply(pre, inverse[q][i], q) == unit(i) + assert apply(tape, unit(i), q) == [q * entry for entry in unit(i)] + cases = [] + ranks = Counter() + for a, b in combinations(range(N), 2): + x, y = counts[a] + u, v = counts[b] + before = sorted((1 + 8*(x+y), 1 + 8*(u+v))) + after = sorted((1 + 8*(x+v), 1 + 8*(u+y))) + assert sum(before) == sum(after) + if after[0] <= before[0]: + status = "tie" if after == before else "worse" + ranks[status] += 1 + cases.append([a, b, before, after, status, None]) + continue + ranks["profitable"] += 1 + vectors = {q: [x-y for x,y in zip(forward[q][a], forward[q][b], strict=True)] + for q in (1, -1)} + duals = {q: [col[a]-col[b] for col in inverse[q]] for q in (1, -1)} + for q in (1, -1): + assert sum(x*y for x,y in zip(vectors[q], duals[q], strict=True)) == 2 + # W - I = -(G d)(d^T G^-1), where d = e_a - e_b. + witness = None + for i, j in ((i, j) for i in range(N) for j in range(N)): + odd = vectors[-1][i]*duals[-1][j] - vectors[1][i]*duals[1][j] + if odd: + witness = [i, j, str(odd)] + break + status = "excluded" if witness else "survives" + cases.append([a, b, before, after, status, witness]) + ranks[status] += 1 + assert len(cases) == 630 + assert next(case for case in cases if case[:2] == [0, 9])[-1] == [0, 0, "4"] + neutral_plus = apply(pre, unit(0), 1) + assert neutral_plus == forward[1][0] + cost = run_path(str(HERE / "inputs/pricing.py"))["cost"] + quote = cost(Counter({73: 192, 137: -96, 9: -96}), Fraction(old["old_crossing_upper"])) + alarm(0) + print(dumps({"pins": PINS, "head": old["head"], "cut": CUT, + "counts": ranks, "budget_seconds": 30, "cases": cases, + "control_pair_0_9_upper": str(quote[1])}, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-signed-phase-leg-four-factor-bound/engines/independent.py b/research/p104-signed-phase-leg-four-factor-bound/engines/independent.py new file mode 100644 index 0000000000..aba78c7f1e --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/engines/independent.py @@ -0,0 +1,227 @@ +"""Exact rational rank of selected four-factor words crossing both extreme hosts.""" +from collections import Counter +from fractions import Fraction as Q +from functools import reduce +from hashlib import sha256 +from itertools import combinations +from json import dumps, loads +from math import gcd, lcm +from pathlib import Path +from signal import SIGALRM, alarm, signal + +ROOT = Path(__file__).resolve().parents[1] +PINS = { + "inputs/R194.json": "49b7dbd3d08c56b16dc43f23bd6f410dde0b98040d922cee6f617786eb474834", + "inputs/R195.json": "f6091c7c63b21145077808bbdacc61431f641d0da37f9fa648aea4b7ead3b472", + "inputs/R193.json": "4926019203f511866cf327128ebcd291561ebc03b6d77a6816361d7128d4664c", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", +} +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +N, SECONDS = 36,45 + + +def unique(items): + obj = dict(items) + assert len(items) == len(obj) + return obj + + +def read(name): + raw = (ROOT/name).read_bytes() + assert sha256(raw).hexdigest() == PINS[name], name + return loads(raw,object_pairs_hook=unique) + + +def dot(a,b): + return sum(x*y for x,y in zip(a,b,strict=True) if x and y) + + +def add(a,b,z): + return [x+z*y for x,y in zip(a,b,strict=True)] if z else a + + +def unit(i): + return [Q(i==j) for j in range(N)] + + +def factors(tape): + # Maintain the q=-1 prefix rows and its inverse columns independently. + g, inv = [unit(i) for i in range(N)], [unit(i) for i in range(N)] + result,labels = [],[] + for t,e in enumerate(tape): + if e[0]=="B": + continue + if e[0]=="J": + _,stage,(x,y,u,v),_ = e + legs = [(y,x,1),(u,v,-1)] + elif e[:2]==["A","QUERY"]: + _,_,d,s,exp = e + assert exp==-1 + stage,legs = 0,[(d,s,1)] + else: + op,d = e[1:3] + if op=="ADD": + s,k = e[3],Q(e[4]) + g[d],inv[s] = add(g[d],g[s],k),add(inv[s],inv[d],-k) + elif op=="SCALE": + k = Q(e[3]) + g[d],inv[d] = [k*x for x in g[d]],[x/k for x in inv[d]] + elif op=="SWAP": + s = e[3] + g[d],g[s] = g[s],g[d] + inv[d],inv[s] = inv[s],inv[d] + else: + assert op in ("LAMBDA","IDLE_ONE") + continue + for n,(d,s,sgn) in enumerate(legs): + u,v = [2*sgn*x for x in inv[d]],g[s].copy() + assert not dot(u,v) + result.append((u,v)) + labels.append([t,stage,n,d,s,sgn]) + g[d],inv[s] = add(g[d],g[s],-sgn),add(inv[s],inv[d],sgn) + for i in range(N): + x = unit(i) + for u,v in result: + x = add(x,u,dot(v,x)) + assert x == [-a for a in unit(i)] + assert [dot(row,inv[i]) for row in g] == unit(i) + return result,labels + + +def packed(factors): + out = [] + for u,v in factors: + du,dv = lcm(*(x.denominator for x in u)),lcm(*(x.denominator for x in v)) + out.append(([int(x*du) for x in u],[int(y*dv) for y in v],du*dv)) + return out + + +def shift_integer(w, u, v, d): + z = dot(v,w) + if not z: + return w + w = [d*x+z*y for x,y in zip(w,u,strict=True)] + g = reduce(gcd,w) + assert g + return [x//g for x in w] if g!=1 else w + + +def integer_transports(core, chosen): + output = [] + chosen_set = set(chosen) + for i in chosen: + u,v,_ = core[i] + for j in range(i+1,chosen[-1]): + if j not in chosen_set: + x,y,d = core[j] + u = shift_integer(u,x,y,d) + v = shift_integer(v,y,[-a for a in x],d) + assert not dot(u,v) + output.append((u,v)) + return output + + +def pivot_columns(rows): + work = [row.copy() for row in rows] + selected = [] + for j in range(len(work[0])): + i = len(selected) + k = next((k for k in range(i,len(work)) if work[k][j]),None) + if k is None: + continue + work[i],work[k] = work[k],work[i] + a = work[i][j] + for k in range(i+1,len(work)): + b = work[k][j] + if b: + work[k] = [a*y-b*x for x,y in zip(work[i],work[k],strict=True)] + selected.append(j) + if len(selected)==len(work): + break + return selected + + +def det(m): + if len(m)==1: + return m[0][0] + return sum((-1)**i * v * det([row[:i]+row[i+1:] for row in m[1:]]) + for i,v in enumerate(m[0]) if v) + + +def exact_deficient(core, chosen): + # Replay the product for any case in which the rank-four sufficient test fails. + shifted = [] + for i in chosen: + u,v = core[i] + for j in range(i+1,chosen[-1]): + if j not in chosen: + x,y = core[j] + u,v = add(u,x,dot(y,u)),add(v,y,-dot(v,x)) + shifted.append((u,v)) + columns = [] + for i in range(N): + e = unit(i) + x = e + for u,v in shifted: + x = add(x,u,dot(v,x)) + columns.append(add(x,e,-1)) + return pivot_columns(columns),shifted + + +def stop(*_): + raise TimeoutError("45-second four-factor cap") + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(SECONDS) + r194,r195,r193,c = [read("inputs/"+x+".json") for x in ("R194","R195","R193","CALLER")] + for old in (r194,r195,r193): + assert (old["head"],old["caller"]) == (HEAD,CALLER) + assert r194["factor_count"] == r195["factor_count"] == 38 + assert not r194["survivors"] and not r195["survivors"] + assert len(r193["records"])==153 and not r193["capped"] + assert all(x["rank"] == 2*(x["hosts"][1]-x["hosts"][0]+1)+x["retained_QUERY"] + for x in r193["records"] if x["hosts"]!=[1,17]) + assert len(c["events"])==4783 and c["types"]["A"]["roles"]==N + original,labels = factors(c["events"]) + assert labels == r194["factor_labels"] == r195["factor_labels"] and len(original)==38 + core = packed(original) + scope = [s for s in combinations(range(38),4) if s[0]<2 and s[-1]>=36] + assert len(scope)==2381 + assert pivot_columns([[1,2],[2,4]]) == [0] and pivot_columns([[1,2],[1,3]])==[0,1] + records,capped = [],False + try: + for ids in scope: + moved = integer_transports(core,ids) + u,v = [x for x,_ in moved],[y for _,y in moved] + a,b = pivot_columns(u),pivot_columns(v) + row = {"factors":ids,"U_pivots":a,"V_pivots":b} + if len(a)==len(b)==4: + ud = det([[x[j] for j in a] for x in u]) + vd = det([[x[j] for j in b] for x in v]) + assert ud and vd + row.update(rank=4,U_minor=ud,V_minor=vd) + else: + piv,shifted = exact_deficient(original,ids) + assert len(piv)<=3 + row.update(rank=len(piv),transported_factors=shifted,product_pivots=piv) + records.append(row) + except TimeoutError: + capped = True + finally: + alarm(0) + assert capped or len(records)==len(scope) + print(dumps({"head":HEAD,"caller":CALLER,"pins":PINS,"factor_labels":labels, + "cap_seconds":SECONDS,"case_cap":len(scope),"capped":capped, + "counts":Counter(x["rank"] for x in records),"records":records, + "survivors":[x for x in records if x["rank"]<=3],"unvisited":scope[len(records):]}, + default=str,sort_keys=True,indent=2)) + if capped: + raise SystemExit(2) + + +if __name__=="__main__": + main() diff --git a/research/p104-signed-phase-leg-four-factor-bound/engines/lead.py b/research/p104-signed-phase-leg-four-factor-bound/engines/lead.py new file mode 100644 index 0000000000..00dbd2a257 --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/engines/lead.py @@ -0,0 +1,149 @@ +"""Try fusing one first-J and one final-J relative rank-one shear.""" +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().parents[1] + + +def dot(a,b): + return sum(x*y for x,y in zip(a,b,strict=True) if x and y) + + +def add(a,b,coef): + return [x+coef*y for x,y in zip(a,b,strict=True)] + + +def stop(*_): + raise TimeoutError("45-second four-factor cap") + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(45) + pins={} + for line in (ROOT/"receipts/LEAD-PINS.txt").read_text().splitlines(): + h,name=line.split() + assert name not in pins and sha256((ROOT/(name if name.startswith("inputs/") else "engines/"+name)).read_bytes()).hexdigest()==h + pins[name]=h + f=run_path(str(ROOT/"engines/forward.py")) + rank=run_path(str(ROOT/"engines/rank_gate.py"))["rank"] + assert pins["inputs/CALLER.json"]==f["PINS"]["inputs/CALLER.json"] + unit,apply=f["unit"],f["apply"] + tape=loads((ROOT/"inputs/CALLER.json").read_bytes())["events"] + price=loads((ROOT/"inputs/R193.json").read_bytes()) + credit=[Q(x)-96 for x in price["per_host_before_new_A_channels"]] + assert credit[0]>0 and credit[1]<96 + factors=[] + for clock,e in enumerate(tape): + if e[0]=="J": + a,b,c,d=e[2] + shears=[(b,a,1),(c,d,-1)] + elif e[:2]==["A","QUERY"]: + assert e[-1]==-1 + shears=[(e[2],e[3],1)] + else: + continue + prefix=tape[:clock] + columns=[apply(prefix,unit(i),-1) for i in range(36)] + for dst,src,coefficient in shears: + u=apply(prefix,unit(dst),-1,inverse=True) + v=[2*coefficient*column[src] for column in columns] + assert not dot(u,v) and apply(prefix,u,-1)==unit(dst) + factors.append((clock,dst,src,u,v)) + assert len(factors)==38 and [p[0] for p in factors[:2]+factors[-2:]]==[43,43,4691,4691] + for i in range(36): + x=unit(i) + for _,_,_,u,v in factors: + x=add(x,u,dot(v,x)) + assert x==[-v for v in unit(i)] + assert apply(tape,unit(i),1)==unit(i) + assert apply(tape,unit(i),-1)==[-v for v in unit(i)] + from itertools import combinations + cases=[p for p in combinations(range(38),4) if p[0]<2 and p[-1]>=36] + assert len(cases)==2381 + proper=[r for r in price["records"] if r["hosts"]!=[1,17]] + assert len(proper)==152 and all(r["rank"]==r["retained_QUERY"]+2*(r["hosts"][1]-r["hosts"][0]+1) + for r in proper) + prime=65521 + assert all(prime%d for d in range(2,256)) + def mod(v): + assert all(x.denominator%prime for x in v) + return [x.numerator*pow(x.denominator,-1,prime)%prime for x in v] + def minus_add(a,b,c): + return [(x+c*y)%prime for x,y in zip(a,b,strict=True)] + def modrank(rows): + piv={} + for v in rows: + r=v.copy() + for k,p in sorted(piv.items()): + if r[k]: + r=minus_add(r,p,-r[k]) + k=next((j for j,x in enumerate(r) if x),None) + if k is not None: + m=pow(r[k],-1,prime) + piv[k]=[(x*m)%prime for x in r] + return sorted(piv) + mf=[(mod(u),mod(v)) for _,_,_,u,v in factors] + records=[] + capped=False + try: + for case in cases: + last=case[-1] + us,vs=[],[] + for i in case: + u,v=mf[i] + for j in range(i+1,last): + if j in case: + continue + a,b=mf[j] + u=minus_add(u,a,dot(b,u)%prime) + v=minus_add(v,b,-dot(v,a)%prime) + assert not dot(u,v)%prime + us.append(u) + vs.append(v) + up,vp=modrank(us),modrank(vs) + out={"case":case,"image_pivots":up,"covector_pivots":vp,"rank":4} + if min(len(up),len(vp))<4: + transported=[] + for i in case: + u,v=factors[i][3:] + for j in range(i+1,last): + if j in case: + continue + _,_,_,a,b=factors[j] + u=add(u,a,dot(b,u)) + v=add(v,b,-dot(v,a)) + assert not dot(u,v) + transported.append((u,v)) + cols=[] + for j in range(36): + base=unit(j) + val=base + for u,v in transported: + val=add(val,u,dot(v,val)) + cols.append(add(val,base,-1)) + out["exact_fallback_rank"]=out["rank"]=len(rank(cols)) + if out["rank"]<4: + out["factors"]=transported + records.append(out) + except TimeoutError: + capped=True + finally: + alarm(0) + print(dumps({"pins":pins,"factors":len(factors),"old_endpoint":"-I", + "upper_gross_with_one_saved_leg":credit,"case_cap":2381, + "runner_cap_seconds":45,"modulus":prime,"records":records, + "capped":capped,"unvisited":len(cases)-len(records), + "survivors":[r["case"] for r in records if r["rank"]<4]}, + indent=2,sort_keys=True,default=str)) + if capped: + raise SystemExit(2) + + +if __name__=="__main__": + main() diff --git a/research/p104-signed-phase-leg-four-factor-bound/engines/rank_gate.py b/research/p104-signed-phase-leg-four-factor-bound/engines/rank_gate.py new file mode 100644 index 0000000000..8ed714b15c --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/engines/rank_gate.py @@ -0,0 +1,56 @@ +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 + + +def stop(*_): + raise TimeoutError("20-second exact gate") + + +def rank(rows): + piv={} + for row in rows: + r=row.copy() + for k,v in sorted(piv.items()): + if r[k]: + r=[x-r[k]*y for x,y in zip(r,v,strict=True)] + k=next((i for i,x in enumerate(r) if x),None) + if k is not None: + piv[k]=[x/r[k] for x in r] + return sorted(piv) + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + alarm(20) + pins={} + for line in (ROOT/"PINS").read_text().splitlines(): + h,p=line.split() + assert p not in pins and sha256((ROOT/p).read_bytes()).hexdigest()==h + pins[p]=h + assert pins["inputs/PRICE.json"]=="1ad9852ecff0b3780770cbf4e500731e65214a9c438f8b1ed2c0cbe484d9b36b" + f=run_path(str(ROOT/"forward.py")) + assert pins["inputs/CALLER.json"]==f["PINS"]["inputs/CALLER.json"] + c=loads((ROOT/"inputs/CALLER.json").read_bytes()) + tape=c["events"][43:269] + assert [(43+i,e[1]) for i,e in enumerate(tape) if e[0]=="J"]==[(43,1),(137,2),(268,3)] + unit,apply=f["unit"],f["apply"] + cols={q:[apply(tape,unit(i),q) for i in range(36)] for q in (1,-1)} + assert all(apply(tape,col,q,inverse=True)==unit(i) for q,xs in cols.items() for i,col in enumerate(xs)) + diff=[[x-y for x,y in zip(a,b,strict=True)] for a,b in zip(cols[1],cols[-1],strict=True)] + piv=rank(diff) + assert rank([unit(i) for i in range(4)])==list(range(4)) + alarm(0) + print(dumps({"pins":pins,"rank":len(piv),"rank_cap":4,"pivot_rows":piv, + "clock_window_inclusive":[43,268],"unit_bodies":True,"signs":[1,-1], + "basis_columns":36,"seconds_cap":20,"delta_entries":[[i,j,str(x)] for j,v in enumerate(diff) + for i,x in enumerate(v) if x]},indent=2,sort_keys=True)) + + +if __name__=="__main__": + main() diff --git a/research/p104-signed-phase-leg-four-factor-bound/inputs/7113-SHA256.json b/research/p104-signed-phase-leg-four-factor-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-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-signed-phase-leg-four-factor-bound/inputs/7113-signed-child.py b/research/p104-signed-phase-leg-four-factor-bound/inputs/7113-signed-child.py new file mode 100644 index 0000000000..0980a6559b --- /dev/null +++ b/research/p104-signed-phase-leg-four-factor-bound/inputs/7113-signed-child.py @@ -0,0 +1,146 @@ +"""Exact nine-slot signed child on the retained 153-coordinate field layout.""" + +from collections import Counter +from hashlib import sha256 +from pathlib import Path +from random import Random +import argparse +import json + +LAYOUT = 153 +EXPECTED_PORTS = (15, 17, 27, 34, 35, 42, 47, 55) +NOTE_SHA = '64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c' +# Integer numerators over 2 in the exact C gate. +C = (((1, 1), (1, -1)), ((1, -1), (1, 1))) +PHASE = ((1, 0), (0, -1), (-1, 0), (0, 1)) + + +def multiply(x, y): + a, b = x + c, d = y + return a*c - b*d, a*d + b*c + + +def conjugate(z): + a, b = z + return a, -b + + +def matrix_product(a, b): + return tuple(tuple(tuple(sum(multiply(a[i][k], b[k][j])[c] for k in range(2)) + for c in range(2)) for j in range(2)) for i in range(2)) + + +def swap_blocks(label, a, b, width): + mask = (1 << width)-1 + delta = ((label >> (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<=36] + assert len(scope) == comb(38,4)-2*comb(36,4)+comb(34,4) == 2381 + assert len(scope) == lead["case_cap"] == other["case_cap"] + assert lead["modulus"] == 65521 and other["counts"] == {"4":2381} + for key,a,b in zip(scope,lead["records"],other["records"],strict=True): + assert key == a["case"] == b["factors"] + assert a["rank"] == b["rank"] == 4 + assert len(a["image_pivots"]) == len(a["covector_pivots"]) == 4 + assert len(b["U_pivots"]) == len(b["V_pivots"]) == 4 + assert b["U_minor"] and b["V_minor"] + + +def main(): + assert __debug__ and implementation.name=="cpython" and version_info[:2]==(3,12) + pins=read((ROOT / "LOCAL-PINS.json").read_bytes()) + for name,digest in sorted(pins.items()): + path = (ROOT / name).resolve() + assert path.is_relative_to(ROOT) and sha256(path.read_bytes()).hexdigest() == digest, name + manifest = read((ROOT / "inputs/7113-SHA256.json").read_bytes()) + assert manifest["expected/ODD-TYPE-AB-CALLER.json"] == pins["inputs/CALLER.json"] + assert manifest["replay/supplier7112/short-caller/signed_child.py"] == pins["inputs/7113-signed-child.py"] + physical_specialization() + data = {} + for stage in STAGES: + result = execute(ROOT / "engines" / f"{stage}.py") + assert result.returncode == 0, (stage,result.stderr.decode()) + assert result.stdout == (ROOT / "receipts" / f"{stage.upper()}.json").read_bytes(), stage + data[stage] = read(result.stdout) + compare(data["lead"],data["independent"]) + corrupted_caller() + print('{"relative_factors":38,"endpoint_crossing_cases":2381,"rank_four":2381,' + '"unresolved":0,"corrupted_caller_rejected":true,"kappa_delta":"0"}') + print("PASS_P104_SIGNED_PHASE_LEG_FOUR_FACTOR_BOUND") + + +if __name__=="__main__": + main()