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-stage17-original-address-extraction-bound/NOTICE.md b/research/p104-stage17-original-address-extraction-bound/NOTICE.md new file mode 100644 index 0000000000..da45fe0867 --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/NOTICE.md @@ -0,0 +1 @@ +The exact source lineage and predecessor credits are in README.md and PROVENANCE.json. OpenAI Codex and subagents materially assisted the proof, implementation, independent verification and packaging. This package is contributed under the repository's Apache-2.0 license. diff --git a/research/p104-stage17-original-address-extraction-bound/PINS.json b/research/p104-stage17-original-address-extraction-bound/PINS.json new file mode 100644 index 0000000000..33bbfa6339 --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/PINS.json @@ -0,0 +1,15 @@ +{ + "PROVENANCE.json": "526bd2faf64e6f6cfbbe593a683be7459855d5dd3dc63f57f1d43f28f99880c6", + "engines/independent.py": "af861fc71c80c81aaab6443cec90cd9f32db4a975470ec0eda94d9e52ae874e9", + "engines/lead.py": "53332afd6faf38cbd91c22ef5c369a6b55fba4273ab5870f2ad56e44aba8c490", + "engines/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "inputs/7113-SHA256.json": "064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078", + "inputs/7113-signed-child.py": "ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b", + "inputs/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/PHYSICAL-BINDING.json": "ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5", + "inputs/PROJECTOR.json": "c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35", + "inputs/R173-INDEPENDENT.json": "d53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32", + "receipts/7416-LEAD.json": "95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26", + "receipts/INDEPENDENT.json": "5a40139322e09d64854e7dbd5a056121ac5a609e9e56ee0a8f5ba685f2bb0986", + "receipts/LEAD.json": "5139517f87fb57c64e1fc8dcb87653415956396a88993f7691fe33a35e155024" +} diff --git a/research/p104-stage17-original-address-extraction-bound/PROOF.md b/research/p104-stage17-original-address-extraction-bound/PROOF.md new file mode 100644 index 0000000000..dc03275c6c --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/PROOF.md @@ -0,0 +1,21 @@ +# Original-address stage-17 residual support + +Fix exact #7334/#7113, clocks 4646 and 4660 and the changed erased map from #7416. Both literal idles multiply Type B role 36 by D, the stage-17 body on axes 137 through 144. All thirteen intervening events are ADD or SCALE on roles 36, 37, 52 and 53. Let M be their invertible scalar role map. It is tensored with the identity on address coordinates throughout the interval. These events introduce no literal Walsh or other address-basis bridge. + +Let e be the coordinate projector onto role 36 and g=M⁻¹eM. Removing M from the output of the old window yields the product of body actions on projectors e and g. The exact normalized replay gives both zero products eg and ge. Thus P=e+g is a rank-two projector, and the old normalized operator is I+P⊗(D−I). Under #7416's grant of the erased action I+P⊗(E−I), the missing operator is P⊗(D−E). The two input lanes are arbitrary and independent in the image of P, where P acts as identity. This matches the exact #7406 normalized projector and leaves the other role directions alone. + +## A nonzero entry in every input column + +For width f≥1, let m=8f. Set a=(1+i)/2. On the original two-point address basis the binary matrix C has diagonal a and off-diagonal −ia. Consequently D=C^(⊗m) has entry a^m(−i)^k between any two addresses at Hamming distance k. Since a^8=1/16, for a single-bit neighbor the entry is −i·2^(−4f). The replay checks one such pair at width one, row 1 and column 0, using the exact pinned binary entries. + +The granted E is ((1+i)I+(1−i)D²)/2. The binary square C² is the address swap by direct multiplication, so D² flips all m bits. E therefore has entries only on equal addresses or full complements. Neither includes a Hamming-distance-one pair because m≥8. The same neighbor entry in D−E is −i·2^(−4f) for every input address at every positive integral width. No additional width experiment is needed for this identity. + +## Consequence for fixed-coordinate extraction + +Take one fixed parked fibre. Suppose the residual supplier only reads selected original-address coordinates, with arbitrary coordinate permutations or subsets. If it omits one input coordinate of one lane, choose a nonzero input supported just on that omitted lane and address. Every supplied observation is then zero. The missing residual output is nonzero at its Hamming neighbor, so the same observations cannot give the correct residual both for this input and for zero. The erased contribution is already supplied separately and does not count as an observation of the missing operator. + +The same argument permits fixed role-scalar mixing at a single address before extraction. If the observed forms at any address have rank less than two on the two-lane space, choose a nonzero lane vector in their common kernel at that address and zero elsewhere. The fixed role-scalar events do not mix different addresses. The residual is again nonzero at the Hamming neighbor. Thus the extractor must retain at least two independent original-coordinate degrees of freedom at every address. This is two full lane volumes in each fixed parked fibre, even for non-affine selection or multiple coordinate-only charts. + +Under the inherited volume-linear rank-16 tariff, write H(r)=r^(1−κ). A charged volume t has gross 16H(8)−8tH(16) across the eight Type B ports. With t≥2 this is negative throughout 0<κ<1. Directed rational bounds at the benchmark give gross upper below −126.39 raw. The positive one-volume quote of about 0.320691708235 raw is therefore unavailable to this extractor. + +The argument leaves arbitrary address-mixing extractors, a separately proved already-paid outside basis bridge, different erased actions, mixed parked fibres and other tariffs open. It concerns the specified residual operator and coordinate-only inputs. No new physical supplier, dirty-restoration construction or recurrence was built. diff --git a/research/p104-stage17-original-address-extraction-bound/PROVENANCE.json b/research/p104-stage17-original-address-extraction-bound/PROVENANCE.json new file mode 100644 index 0000000000..1c692128a8 --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/PROVENANCE.json @@ -0,0 +1,43 @@ +{ + "benchmark": { + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "kappa": "0.00364665195644", + "pr": 7334 + }, + "caller": { + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "manifest": "research/signed-caller-8x9/SHA256.json", + "path": "research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json", + "pr": 7113, + "sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" + }, + "predecessors": [ + { + "credit": "Changed erased shell, Walsh affine-hull bound, physical source pins and directed tariff interval.", + "head": "8401b466472bc1a7e5b1fc6c8ba21c5de056e4b9", + "package": "research/p104-stage17-parity-shell-affine-bound", + "pr": 7416 + }, + { + "credit": "Literal two-return span and normalized independent role projector.", + "head": "a5fa7b464a773afb47eb8b9725b94f660c407528", + "pr": 7406 + }, + { + "credit": "Conditional volume-linear tariff.", + "head": "cd23b74fe48aa65b8007c1fd9af57246f4ebc2dd", + "pr": 7397 + }, + { + "credit": "Directed rank-power arithmetic.", + "head": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "pr": 7362 + } + ], + "receipt_transport": { + "changes": "Only replay-root path keys normalized to bundled paths. Exact data fields preserved.", + "independent_original_sha256": "e2fd2edf0d856ff7be2879f5cdf14432e5a6415b449a98a9bacde75449542596", + "lead_original_sha256": "ef6b6ca30ff9886c0ac002239c8f4e1d718a7a96c3b1133c162fee7e4a7f29a7" + }, + "schema_version": 1 +} diff --git a/research/p104-stage17-original-address-extraction-bound/README.md b/research/p104-stage17-original-address-extraction-bound/README.md new file mode 100644 index 0000000000..fca36f609f --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/README.md @@ -0,0 +1,19 @@ +# Bound original-address extraction of the stage-17 body shell + +On the exact [#7334 comparator](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) and [#7113 caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113), retain the two-return stage-17 residual and changed erased map from [#7416](https://github.com/CrocSwap/integer-mult-bounds/pull/7416). Test arbitrary coordinate selection in the original address basis on the two independent residual lanes, including non-affine subsets. + +One exact Hamming-neighbor residual entry is −i/16 at width one. Its translation orbit meets every input column at every positive integral width. The fixed 13-event interval contains only role scalars, so it supplies no literal address-basis bridge. A coordinate-only extractor must preserve both full lane volumes in each fixed parked fibre. Under the inherited rank-16 tariff, the directed gross upper is below −126.39 raw. No complete construction or exponent change follows. + +Run the replay from the clean checkout root on POSIX with CPython 3.12. + +```sh +python3.12 -I -B research/p104-stage17-original-address-extraction-bound/replay.py +``` + +The replay authenticates bundled sources by path, regenerates both exact receipts and rejects a corrupted caller. It needs no network, Git metadata, previous temporary state or external Python packages. Expected marker `PASS_STAGE17_ORIGINAL_ADDRESS`. + +## Open next questions + +Could a different extractor mix addresses or reuse an independently justified outside Walsh frame within the positive one-volume budget? Start with one literal basis bridge or coordinate-mixing operator on axes 137 through 144. Price the full ingress and egress, preserve both dirty inputs and parked fibres, and prove exact restoration. The fixed interval result leaves such changed constructions open. + +[#7416](https://github.com/CrocSwap/integer-mult-bounds/pull/7416) supplies the erased map, earlier Walsh affine-chart result and directed price interval. [#7406](https://github.com/CrocSwap/integer-mult-bounds/pull/7406) supplies the original two-return projector, [#7397](https://github.com/CrocSwap/integer-mult-bounds/pull/7397) the volume tariff, and [#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) the directed rank-power arithmetic. OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging. diff --git a/research/p104-stage17-original-address-extraction-bound/SOURCES.json b/research/p104-stage17-original-address-extraction-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-stage17-original-address-extraction-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-stage17-original-address-extraction-bound/TASK.json b/research/p104-stage17-original-address-extraction-bound/TASK.json new file mode 100644 index 0000000000..e444ba093d --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/TASK.json @@ -0,0 +1,91 @@ +{ + "actual_scope": "One original-address Hamming-neighbor entry at width one, a closed-form extension to all positive integral widths, and the exact 13 intervening role-scalar events on two independent residual lanes of the #7113 caller.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 stage-17 original-address extraction audit", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "The optimistic one-volume rank-16 residual supplier is positively priced only if extraction preserves the full dirty input contract while avoiding a second lane volume.", + "budget_minutes": 4, + "evidence": "The exact Hamming-neighbor residual entry is \u2212i/16, and its translation orbit meets every original input column. The literal interval has 11 ADD and two SCALE operations and supplies no address-basis bridge. All coordinate-only extractors in this fixed original basis require two old lane volumes.", + "open_questions": [ + { + "blocked_by": "The fixed interval contains only role scalars, and coordinate selection loses a nonzero column if it omits any independent input in a parked fibre.", + "first_step": "Specify one exact coordinate-mixing operator or inherited outside frame and price both basis boundaries, full dirty restoration and the candidate residual call.", + "question": "Can a separately justified mixed extractor carry the two residual lanes in a common Walsh frame without exhausting the positive one-volume quote?", + "why_it_matters": "The residual has fewer than one lane volume in its spectral basis, while every original-address input coordinate affects it." + } + ], + "original_card": { + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "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/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "status": "author-checked" + }, + { + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "scope": "PR #3801: successor scatter-boundary decision package.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "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": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "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": "supplier-boundary-audit", + "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": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "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" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "Resolve original-address coordinate-only extraction of a precisely pinned stage-17 body residual before attempting a new supplier.", + "scope_status": "changed", + "stop_rule": "One width-one address pair and one 13-event frame trace, each implementation capped at 20 runner seconds. No other width/profile or outside frame search.", + "task_id": "supplier-boundary-audit" +} diff --git a/research/p104-stage17-original-address-extraction-bound/VERIFICATION.md b/research/p104-stage17-original-address-extraction-bound/VERIFICATION.md new file mode 100644 index 0000000000..a79eee522e --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/VERIFICATION.md @@ -0,0 +1 @@ +The lead and independent runners each used one width-one original-address pair and the full 13 intervening events with a 20-second cap. They finished in 0.05 and 0.03 seconds respectively on CPython 3.12. The independent path parses the exact binary gate numerators without executing the predecessor module, rebuilds the literal four-role window and its inverse from separate forward and reverse basis walks, and matches the exact rank-two projector from #7406. The lead path uses the signed child and directed power functions to reproduce the selected axes, Gaussian entry and price. Both regenerate deterministic path-keyed receipts. The standalone wrapper rejects changed caller bytes and checks the same exact window, residual entry and volume. The all-width statement follows from the tensor entry formula in PROOF.md. No additional width, profile or outside frame was tested. diff --git a/research/p104-stage17-original-address-extraction-bound/VERIFY.json b/research/p104-stage17-original-address-extraction-bound/VERIFY.json new file mode 100644 index 0000000000..a4674a155c --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Regenerate both one-entry exact receipts, rebuild the scalar projector, check directed price and reject a corrupted caller.", + "timeout_seconds": 60 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-stage17-original-address-extraction-bound/engines/independent.py b/research/p104-stage17-original-address-extraction-bound/engines/independent.py new file mode 100644 index 0000000000..8b5133a2bd --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/engines/independent.py @@ -0,0 +1,154 @@ +"""Check one original-address stage-17 residual entry and the fixed scalar interval.""" +from ast import Assign, Name, literal_eval, parse +from collections import Counter +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 +from sys import argv, implementation, version_info + +CAP = 20 +CLOCKS = (4646, 4660) +ROLES = (36, 37, 52, 53) +AXES = tuple(range(137, 145)) +HEAD = 'aaeec8c0acf01e99a5f331ef363a698d9c084ace' +CALLER = '07a76c5e2738882c0cb322278e56f6cae3c9885d' +PINS = { + 'inputs/7113-SHA256.json': '064e11ecfedce9937ea1782e5baee37e89b3c9eebabed5b4a9ba84f412bbe078', + 'inputs/7113-signed-child.py': 'ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b', + 'inputs/CALLER.json': '255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', + 'inputs/PHYSICAL-BINDING.json': 'ade5f8cbb2e30677b1d48d23a1aa270b3d0b72e2504472ab9fdb71d124b075b5', + 'inputs/R173-INDEPENDENT.json': 'd53dfc746467daff3bddf25fd7d2ce11d2d984f0bd71c14d18277c6a0dad7b32', + 'receipts/7416-LEAD.json': '95f89deb1952b9e72181dbfc58e72208a27b14ba014839ec19bf8505bb2f0f26', +} + + +def unique(pairs): + values = dict(pairs) + assert len(values) == len(pairs), 'duplicate JSON key' + return values + + +def source(root, path): + data = (root / path).read_bytes() + assert sha256(data).hexdigest() == PINS[path], f'wrong input hash: {path}' + return loads(data, object_pairs_hook=unique) if path.endswith('.json') else data + + +def gaussian_product(left, right): + a, b = left + c, d = right + return a*c - b*d, a*d + b*c + + +def address_entry(child): + numerator = next(literal_eval(node.value) for node in parse(child).body + if isinstance(node, Assign) and isinstance(node.targets[0], Name) + and node.targets[0].id == 'C') + gate = tuple(tuple(tuple(Q(x, 2) for x in entry) for entry in row) for row in numerator) + a = (Q(1, 2), Q(1, 2)) + assert all(gate[r][s] == (a if r == s else gaussian_product(a, (0, -1))) + for r in (0, 1) for s in (0, 1)) + # Probe one original-address neighbour, x=0 and y=1. The diagonal + # product on eight bits also fixes the scalar in the all-width formula. + result, diagonal = (Q(1), Q(0)), (Q(1), Q(0)) + for bit in range(len(AXES)): + result = gaussian_product(result, gate[(1 >> bit) & 1][0]) + diagonal = gaussian_product(diagonal, a) + assert diagonal == (Q(1, 16), Q(0)) and result == (Q(0), Q(-1, 16)) + # E uses only the identity and the full eight-bit complement. + assert 1 not in (0, (1 << len(AXES)) - 1) + return result + + +def apply(events, column, inverse=False): + for _, op, dest, *args in reversed(events) if inverse else events: + i = ROLES.index(dest) + if op == 'ADD': + src, coefficient = args + column[i] += (-1 if inverse else 1) * Q(coefficient) * column[ROLES.index(src)] + else: + coefficient, = args + column[i] *= Q(coefficient) ** (-1 if inverse else 1) + return column + + +def multiply(left, right): + return [[sum(a*b for a,b in zip(row, column, strict=True)) + for column in zip(*right, strict=True)] for row in left] + + +def frame_trace(caller, inherited): + start, stop = CLOCKS + tape = caller['events'] + assert len(tape) == 4783 and caller['ambient_rank'] == 145 + assert all(tape[clock] == ['B', 'IDLE_ONE', 36, [17]] for clock in CLOCKS) + middle = tape[start + 1:stop] + counts = Counter() + for kind, op, dest, *args in middle: + assert kind == 'B' and op in ('ADD', 'SCALE') and dest in ROLES + if op == 'ADD': + assert args[0] in ROLES and args[0] != dest + else: + assert Q(args[0]) + counts[op] += 1 + assert len(middle) == 13 and counts == {'ADD': 11, 'SCALE': 2} + identity = [[Q(i == j) for j in range(len(ROLES))] for i in range(len(ROLES))] + m, mi = [list(map(list, zip(*(apply(middle, x.copy(), inverse) for x in identity), strict=True))) + for inverse in (False, True)] + assert multiply(m, mi) == multiply(mi, m) == identity + assert m[0][0] == mi[0][0] == 0 + e = [[Q(i == j == 0) for j in range(len(ROLES))] for i in range(len(ROLES))] + f = multiply(multiply(mi, e), m) + assert not any(any(row) for product in (multiply(e, f), multiply(f, e)) for row in product) + p = [[a+b for a,b in zip(x,y,strict=True)] for x,y in zip(e,f,strict=True)] + assert multiply(p, p) == p and sum(p[i][i] for i in range(len(ROLES))) == 2 + assert p == [[Q(x) for x in row] for row in inherited['projector']] + return middle, counts, p + + +def stop(*_): + raise TimeoutError('20-second fixed stage-17 original-address gate cap') + + +def main(root): + assert __debug__ and implementation.name == 'cpython' and version_info[:2] == (3, 12) + signal(SIGALRM, stop) + alarm(CAP) + manifest = source(root, 'inputs/7113-SHA256.json') + for bundled, original in [('CALLER.json', 'expected/ODD-TYPE-AB-CALLER.json'), + ('PHYSICAL-BINDING.json', 'expected/ODD-PHYSICAL-BINDING.json'), + ('7113-signed-child.py', 'replay/supplier7112/short-caller/signed_child.py')]: + assert manifest[original] == PINS[f'inputs/{bundled}'] + caller = source(root, 'inputs/CALLER.json') + binding = source(root, 'inputs/PHYSICAL-BINDING.json') + child = source(root, 'inputs/7113-signed-child.py') + inherited = source(root, 'inputs/R173-INDEPENDENT.json') + price = source(root, 'receipts/7416-LEAD.json') + assert (inherited['benchmark'], inherited['caller'], inherited['clocks']) == (HEAD, CALLER, list(CLOCKS)) + assert (price['head'], price['caller'], price['clocks']) == (HEAD, CALLER, list(CLOCKS)) + assert binding['caller_sha256'] == PINS['inputs/CALLER.json'] + assert binding['occurrence_and_geometry']['ambient'] == 145 + assert inherited['stage'] == 17 and inherited['physical_stage_axes'] == list(AXES) + assert inherited['ports'] == caller['types']['B']['ports'] == [15, 17, 27, 34, 35, 42, 47, 55] + middle, counts, p = frame_trace(caller, inherited) + result = address_entry(child) + gross = price['affine_chart_raw_gain'] + assert Q(gross[1]) < Q('-126.39') + assert Q(price['rank16_affordability'][1]) < Q('1.003') + alarm(0) + print(dumps({'head': HEAD, 'caller': CALLER, 'pins': PINS, 'clocks': CLOCKS, + 'inherited_axis_ids': AXES, 'window': middle, 'role_scalar_counts': counts, + 'literal_address_basis_bridge_in_window': False, + 'normalized_role_projector': [[str(x) for x in row] for row in p], + 'normalized_residual_lanes': 2, 'width': 1, 'address_pair': [1, 0], + 'residual_entry': [str(x) for x in result], + 'all_width_hamming_neighbour': '-i * 2^(-4f)', + 'coordinate_only_minimum_old_lane_volumes': 2, + 'two_lane_raw_interval_from_7416': gross, 'runner_cap_seconds': CAP}, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + assert len(argv) == 2, 'pass the package root with bundled pinned inputs' + main(Path(argv[1]).resolve()) diff --git a/research/p104-stage17-original-address-extraction-bound/engines/lead.py b/research/p104-stage17-original-address-extraction-bound/engines/lead.py new file mode 100644 index 0000000000..d077964768 --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/engines/lead.py @@ -0,0 +1,60 @@ +"""One exact translation witness for original-address stage-17 extraction.""" +from fractions import Fraction as F +from hashlib import sha256 +from json import dumps,loads +from pathlib import Path +from runpy import run_path +from signal import alarm + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent +PINS = { + 'inputs/CALLER.json':'255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', + 'inputs/PROJECTOR.json':'c36cb8d3fae7bccd15566c2f83f2d2bd8abeeb334381cbf3212d5d9b3d965c35', + 'engines/pricing.py':'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', + 'inputs/7113-signed-child.py':'ef03444360f02225138be9b38e2f9a85f313eeaa910d63a365de0f16d228cb8b', +} + + +def main(): + assert __debug__ + alarm(20) + for name,digest in PINS.items(): + assert sha256((ROOT/name).read_bytes()).hexdigest() == digest + caller = loads((ROOT/'inputs/CALLER.json').read_bytes()) + tape = caller['events'] + assert tape[4646] == tape[4660] == ['B','IDLE_ONE',36,[17]] + window = tape[4647:4660] + assert len(window) == 13 and all(e[:2] in (['B','ADD'],['B','SCALE']) for e in window) + roles = sorted({r for e in window for r in e[2:4 if e[1]=='ADD' else 3]}) + assert roles == [36,37,52,53] + expected = loads((ROOT/'inputs/PROJECTOR.json').read_bytes()) + assert expected['rank'] == 2 and expected['inclusive_window'] == [4646,4660] + child = run_path(str(ROOT/'inputs/7113-signed-child.py')) + multiply = child['multiply'] + _, body = child['masks'](17,1) + axes = [j for j in range(153) if body >> j & 1] + assert axes == list(range(137,145)) + matrix = child['C'] + assert matrix[0][0] == matrix[1][1] and matrix[0][1] == matrix[1][0] + coefficient = matrix[1][0] + for _ in range(7): + coefficient = multiply(coefficient,matrix[0][0]) + neighbour = [F(v,2**8) for v in coefficient] + assert neighbour == [0,F(-1,16)] + # E is a combination of identity and the all-eight-bit flip, so this entry is zero. + assert 1 not in (0,2**8-1) + h = run_path(str(HERE/'pricing.py'))['power_bounds'] + lo,hi = map(F,('0.00364665195644044790699554028334161','0.00364665195644044790699554028334162')) + quote_one = 16*h(8,hi)[0]-8*h(16,lo)[1] + quote_two = 16*h(8,lo)[1]-16*h(16,hi)[0] + assert quote_one > 0 and quote_two < -126 + alarm(0) + print(dumps({'pins':PINS,'clocks':[4646,4660],'body_axes':axes,'roles':roles,'window':window, + 'neighbour_D_minus_E':list(map(str,neighbour)), 'neighbour_residue_projector':'1/32', + 'arbitrary_coordinate_extraction_volume':2,'one_volume_gross_lower':str(quote_one), + 'two_volume_gross_upper':str(quote_two),'case_cap':1,'runner_cap_seconds':20},sort_keys=True,indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-stage17-original-address-extraction-bound/engines/pricing.py b/research/p104-stage17-original-address-extraction-bound/engines/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-stage17-original-address-extraction-bound/engines/pricing.py @@ -0,0 +1,82 @@ +"""Directed interval arithmetic and the retained signed BIT invoice.""" +from collections import Counter +from fractions import Fraction +from functools import cache + +TARGET = "10018846261809/2500000000000000" +SCALE = 10**49 + + +def rounded(x, upper): + scaled = SCALE*x + if upper: + return Fraction(-((-scaled.numerator) // scaled.denominator), SCALE) + return Fraction(scaled.numerator // scaled.denominator, SCALE) + + +@cache +def log_bounds(x): + z = (x-1)/(x+1) + terms = 60 + exact_partial = 2*sum(z**(2*i+1)/(2*i+1) for i in range(terms)) + tail = 2*z**(2*terms+1)/((2*terms+1)*(1-z*z)) + return rounded(exact_partial, False), rounded(exact_partial+tail, True) + + +@cache +def power_bounds(rank, k): + binary = 2**(rank.bit_length()-1) + shift = binary.bit_length()-1 + l2, u2 = log_bounds(Fraction(2)) + lo, hi = log_bounds(Fraction(rank, binary)) + lo, hi = k*(lo+shift*l2), k*(hi+shift*u2) + assert 0 <= lo <= hi < 1 + + def exponential(z, terms): + total = term = Fraction(1) + for i in range(1, terms+1): + term *= -z/i + total += term + return total + + return rounded(rank*exponential(hi, 35), False), rounded(rank*exponential(lo, 34), True) + + +def cost(hist, k): + lower = upper = Fraction(0) + for r, n in hist.items(): + a, b = (n*x for x in power_bounds(r, k)) + lower += min(a, b) + upper += max(a, b) + return lower, upper + + +def profile(invoice, native, word, ranks): + copies = invoice["native_calls"] + assert copies == len(invoice["native_instances"]) == 36 + assert {tuple((r["stage"], r["copy"])) for r in invoice["native_instances"]} == { + (stage, which) for stage in range(1, 19) for which in (0, 1) + } + assert all(r["ports"] == 111 for r in invoice["native_instances"]) + assert native == Counter({int(r): n for r, n in invoice["native_paid"].items()}) + assert sum(native.values()) == 2871 + caller_paid = {1: 444, **{r: 444 for r in range(7, 57, 7)}} + assert invoice["event_counts"]["QUERY"]*111 == caller_paid[1] + assert invoice["event_counts"]["IDLE_ONE"]*111 == 8*444 + full_paid = Counter({r: copies*n for r, n in native.items()}) + full_paid.update(caller_paid) + + helpers = Counter(ranks[word["final"][j]]-ranks[word["start"][j]] + for j in range(222, word["public"])) + assert helpers == Counter({int(r): n for r, n in invoice["native_helpers"].items()}) + caller_targets = {**{r: 444 for r in range(8, 65, 7)}, 127: 222} + full_targets = Counter({r: copies*n for r, n in helpers.items()}) + full_targets.update(caller_targets) + assert full_paid == Counter({int(r): n for r, n in invoice["paid"].items()}) + assert full_targets == Counter({int(r): n for r, n in invoice["targets"].items()}) + assert sum(full_paid.values()) == invoice["paid_jobs"] + assert sum(full_targets.values()) == invoice["productive_fields"] + signed = full_targets.copy() + signed.subtract(full_paid) + assert sum(r*n for r, n in signed.items()) == invoice["rank_surplus"] + return signed, copies diff --git a/research/p104-stage17-original-address-extraction-bound/inputs/7113-SHA256.json b/research/p104-stage17-original-address-extraction-bound/inputs/7113-SHA256.json new file mode 100644 index 0000000000..5a7d6b80dc --- /dev/null +++ b/research/p104-stage17-original-address-extraction-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-stage17-original-address-extraction-bound/inputs/7113-signed-child.py b/research/p104-stage17-original-address-extraction-bound/inputs/7113-signed-child.py new file mode 100644 index 0000000000..0980a6559b --- /dev/null +++ b/research/p104-stage17-original-address-extraction-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<