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-role1501-owned-move-fusion-bound/7481-APPLICATION.json b/research/p104-role1501-owned-move-fusion-bound/7481-APPLICATION.json new file mode 100644 index 0000000000..28390c8bb4 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/7481-APPLICATION.json @@ -0,0 +1,76 @@ +{ + "status": "PASS_COMPLETE_CONDITIONAL_CHANGED_PRODUCER", + "source_head": "58a9d052143f5d85295ed2d0163591c47f89a331", + "canonical_main_pin": "e54523517d0f03e58352e647c403a5af3e525a57", + "caller_head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate_canonical_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8", + "candidate_gzip_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "conditional_claim": "3647081039689/1000000000000000", + "claim_decimal": "0.003647081039689", + "comparison_claim": "729355574567/200000000000000", + "exact_claim_improvement": "151583427/500000000000000", + "directed_crossing_bracket": [ + "9117702599223995588631135479313/2500000000000000000000000000000000", + "36470810396895982354524541917253/10000000000000000000000000000000000" + ], + "native_paid_delta": { + "1": 1, + "3": -1, + "4": -1, + "6": 1 + }, + "native_productive_delta": {}, + "signed_paid_delta": { + "1": 17, + "3": -17, + "4": -17, + "6": 17 + }, + "signed_productive_delta": {}, + "paid_calls": 110519, + "productive_calls": 22461, + "surplus": 1424, + "empty_credit": 0, + "native_events": 76475, + "added_operations": { + "ADD": 3 + }, + "owned_labels": 68, + "owned_lifetimes": 74, + "owned_peak": 50, + "grid": { + "odd_scale": 1125, + "fractional_bits": 25 + }, + "ordinary_bound": 782785912, + "ordinary_increase": 1360, + "precision_coefficient": 2430, + "fixed_tape": { + "native_invocations": 17, + "monomial_map_slots": 298808, + "elementary_records_upper": 25477565312, + "scalar_services_upper": 43830720, + "context_c": 2430 + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "receipt_sha256": { + "validation_native/NATIVE-RESULT.json": "4f2024c0a84be0389a2f0469a0ea3f27af995b17fa641211c94a34807b8624f9", + "validation_signed/RESULT.json": "e5c8d8c0cf4d3f3fc60ffe70eb084cf6c9eadf8e646c74b48762501bf5367474", + "reroute/INDEPENDENT-RESULT.json": "7dba1b98b3b102c714bca9cbdea2826e74e759194dfb92026c9ca293f0fc17a2", + "reroute/ADVERSARIAL.json": "4029026fa0e7f13a70b8aca8a7dc4efcbe9347f98eb975d96c1db285683358f7" + }, + "scope": "Fresh source-aware local replay under the five retained assumptions. No maintainer selection or canonical edit is made." +} diff --git a/research/p104-role1501-owned-move-fusion-bound/7481-WORD.json.gz b/research/p104-role1501-owned-move-fusion-bound/7481-WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-role1501-owned-move-fusion-bound/7481-WORD.json.gz differ diff --git a/research/p104-role1501-owned-move-fusion-bound/NOTICE.md b/research/p104-role1501-owned-move-fusion-bound/NOTICE.md new file mode 100644 index 0000000000..7ded0b3d76 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/NOTICE.md @@ -0,0 +1 @@ +Apache-2.0. #7481 supplies the exact native word, crossing and signed application. #7480 and #7334 supply the retained native construction lineage. #7113 supplies the exact signed caller and 17-fold invoice. #7482 supplies the exact sparse tape and rank routines. #7298 and #7362 supply the directed tariff lineage. The #7481 literal INIT33813, guarded COPY33814, ADD33817 and ADD40568 supply the old donor and recipient contract. #7485 supplies a related fixed-bank bypass decision for a different public role. OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging. diff --git a/research/p104-role1501-owned-move-fusion-bound/PINS.json b/research/p104-role1501-owned-move-fusion-bound/PINS.json new file mode 100644 index 0000000000..32c89d8446 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/PINS.json @@ -0,0 +1,11 @@ +{ + "7481-APPLICATION.json": "1d93fae969ff24ecb91bb4bee6af74daaa9ea99141bcf630a77eeb1a167b1799", + "7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "PROVENANCE.json": "6274fc7326bbd2260d863f4f74db62bce780ebf3ae31bec9f75a1fdadd83b52e", + "fuse_1501.py": "1113a142bcec8e2f3ab6e54560b3d4dfeb85d07bc1033add2a3470cfe0bc9deb", + "gate.py": "aa13cd2797877ef7328d5bcda24be51815fddcc4e8ae091382ad963fb978e5e9", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/DENSE.json": "3bca185f1206a45ac13d7881789c7029e88f572e8918889f044b42f6663ecbf2", + "receipts/SPARSE.json": "ac26db6508730f9781e05a354990e174cb5df7fb7dceba2032fa8140ea64f594", + "verify_fusion_probe.py": "6aed34ee876ea0f9068ca9c9518b106b9fa14e8bcbc878324b50cb5fff743d95" +} diff --git a/research/p104-role1501-owned-move-fusion-bound/PROOF.md b/research/p104-role1501-owned-move-fusion-bound/PROOF.md new file mode 100644 index 0000000000..46aab4558b --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/PROOF.md @@ -0,0 +1,13 @@ +# Endpoint span obstruction to fusing the role 1501 route + +Use exact [#7481 at 89eaa9d8cae37c1540de98f2d29a3abaabb96a2b](https://github.com/CrocSwap/integer-mult-bounds/pull/7481) and the [#7113 signed caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113). All clocks below are zero-based. The old source path is MOVE40563 from chart 549 to chart 115, then MOVE40567 from chart 115 to chart 593. The dimensions are 7, 5 and 1 and the binary spans are strictly nested. The single intervening role-1501 contact is `1501 += 1525/4` at ADD40564. Keep CLEAR40565 of owned 1525, the old arrival of role 174 at MOVE40566, and the required effect of ADD40568 `174 -= 2*1501`. + +The declared candidate replaces those two moves by the direct chart 549→593 move and gives the carrier its old pre-MOVE40563 value. It grants arbitrary rational operations on the unchanged two endpoint banks, including reversible changes of basis and any coframed zero scratch. It retains the other arrivals and scalar contacts, so the direct carrier introduces no linear direction beyond the chart-549 bank. Combining those rows with the live chart-593 bank is a relaxation of what the direct route can use. + +The input-independent zero owned INIT33813, COPY33814 from public 770 and subtraction of public 607 at ADD33817 supply the missing old donor `x770−x607`. Its full backward covector at ADD40564 has exactly these two coefficients. The endpoint bank ranks are checked together. Their union has rank 15 and adding this donor row raises rank to 16. + +Take arbitrary public input 10 = −1, input 173 = −1/2, input 607 = −1 and all other public inputs zero. On this input the 11 rows at chart 549 before MOVE40563 and the six rows at chart 593 before MOVE40567 are all zero, as on the zero input. In particular old role 1501 is zero at the entrance and old recipient 174 is zero at the exit. The donor is one on this probe, and the retained ADD40568 would contribute −1/2. On the zero input it contributes zero. Endpoint correction and a direct carrier derived from these rows cannot distinguish the two inputs. This rules out the required signed output of role 174 within the declared scope. + +The paid native delta would be {2:−1, 4:−1, 6:+1}, multiplied by 17 in the signed caller, with no productive change. Directed arithmetic at the exact comparator crossing gives gross old-minus-new moment strictly between 0.2355 and 0.2356 raw. Any new paid position would exceed this saving. A physical implementation would still require exact signed chart phases, ownership and restoration, ordinary work, precision and tape verification. The excluded route realizes no saving. + +The funded public bypass in #7481 changes a separate pair of paths. The role-235 bound in #7485 tests another fixed bank and a public read. This contribution concerns an owned carrier, a supplied old operand from a guarded COPY, and the joint span of the two specific endpoint banks. It leaves changed pre-capture, intermediate or downstream cuts and re-encoded external arrivals open. diff --git a/research/p104-role1501-owned-move-fusion-bound/PROVENANCE.json b/research/p104-role1501-owned-move-fusion-bound/PROVENANCE.json new file mode 100644 index 0000000000..b3e8b55a36 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/PROVENANCE.json @@ -0,0 +1,37 @@ +{ + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementations, independent replay and packaging.", + "caller": { + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "pr": 7113, + "replayed_copy_relative_to_7481_package": "inputs/pr7113/ODD-TYPE-AB-CALLER.json" + }, + "comparator": { + "application": "producer54/APPLICATION.json", + "head": "89eaa9d8cae37c1540de98f2d29a3abaabb96a2b", + "kappa": "0.003647081039689", + "package": "research/p104-funded-485-1455-return", + "pr": 7481, + "tree": "984434b58abc2d69c3cf45609a755be566c6ac91", + "word": "producer54/reroute/WORD.json.gz" + }, + "credits": { + "7113": "Signed fixed caller supplies 17 native invocations.", + "7298": "Directed signed tariff lineage.", + "7334": "Earlier complete signed comparator and retained native layout.", + "7362": "Exact directed stock and tariff arithmetic lineage.", + "7480": "Preceding return construction and unchanged signing lineage.", + "7481": "Exact active word and application, including old role 1525 producer and role 174 outward ADD.", + "7482": "Exact rational tape and row rank routines in gate.py.", + "7485": "Related fixed-bank bypass for a distinct public role and cut." + }, + "reused_engines": { + "files": [ + "gate.py", + "pricing.py" + ], + "head": "db68969c04ce473128364f42eec8273734f02326", + "package": "research/p104-owned-productive-cut-bound", + "pr": 7482 + }, + "schema_version": 1 +} diff --git a/research/p104-role1501-owned-move-fusion-bound/README.md b/research/p104-role1501-owned-move-fusion-bound/README.md new file mode 100644 index 0000000000..c5edd222c9 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/README.md @@ -0,0 +1,15 @@ +# Bound the role 1501 owned move fusion + +**NO VERIFIED GAIN.** On exact [#7481](https://github.com/CrocSwap/integer-mult-bounds/pull/7481), owned role 1501 moves through charts 549, 115 and 593. Fusing its rank-two and rank-four moves saves strictly between 0.2355 and 0.2356 raw across the complete signed caller before correction. The intervening contribution from owned 1525 is outside the combined span of the two endpoint banks, including the old carrier value. Exact forward replay finds a public input with both endpoint banks zero and the old outward ADD increment −1/2. + +One role, one route and one fixed intermediate ADD were exhausted. From a clean POSIX checkout with CPython 3.12 and assertions enabled, run: + +```sh +python3.12 -I -B research/p104-role1501-owned-move-fusion-bound/replay.py +``` + +[Proof and exact scope](PROOF.md) · [Verification](VERIFICATION.md) · [Source pins and credit](PROVENANCE.json) + +## Open next questions + +The missing direction could be carried by an earlier paid arrival only if that route preserves its own independent return and all required old reads. The first next test is to identify one existing pre-cut path that is nonzero on the separator and to price it before construction. A newly added rank-one native charge alone exceeds the gross saving under the retained caller. diff --git a/research/p104-role1501-owned-move-fusion-bound/SOURCES.json b/research/p104-role1501-owned-move-fusion-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-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-role1501-owned-move-fusion-bound/TASK.json b/research/p104-role1501-owned-move-fusion-bound/TASK.json new file mode 100644 index 0000000000..f7033a0ea3 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7481 and #7113. One owned role 1501 route, MOVE40563/40567, old guarded-COPY donor1525 at ADD40564 and signed recipient174 at ADD40568. Grant arbitrary scalar correction from both unchanged endpoint banks.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 owned role 1501 monotone MOVE fusion", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "A direct rank-six move replaces paid ranks two and four if the intermediate read can be restored. The complete signed gross is between 0.2355 and 0.2356 raw before correction.", + "budget_minutes": 10, + "evidence": "The two endpoint banks have rank fifteen and the omitted donor raises it to sixteen. Independent forward replay confirms zero endpoint rows and old outward increment \u22121/2 on the separator.", + "open_questions": [ + { + "blocked_by": "The unchanged endpoint banks and original carrier annihilate the public separating input.", + "first_step": "Find one existing earlier arrival carrying the missing direction and require exact restoration and complete positive price.", + "question": "Can a changed existing paid path deliver the omitted guarded-COPY contribution?", + "why_it_matters": "A legal rank-six replacement strictly reduces the binding paid complex moment." + } + ], + "original_card": { + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "existing_checks": [ + { + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4133: literal-slot defect", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4136: uniform commutation gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "status": "author-checked" + }, + { + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4140: uniform encoding gap", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "status": "author-checked" + }, + { + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "status": "author-checked" + }, + { + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "scope": "PR #4154: fiber-tag seam mismatch", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "status": "author-checked" + }, + { + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "status": "reviewed" + } + ], + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "id": "p104-side-correction", + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ] + }, + "outcome": "negative-result", + "priority_revision": 8, + "schema_version": 1, + "scope_change_reason": "Fuse two monotone owned moves while preserving the one intermediate read and complete fixed endpoint contract.", + "scope_status": "changed", + "stop_rule": "One owned route, one intermediate ADD and two fixed endpoint banks, capped at 30 seconds per engine. Stop on a signed separator or exact span result.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-role1501-owned-move-fusion-bound/VERIFICATION.md b/research/p104-role1501-owned-move-fusion-bound/VERIFICATION.md new file mode 100644 index 0000000000..c677677301 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/VERIFICATION.md @@ -0,0 +1,5 @@ +# Verification + +The rational backward engine authenticates the exact compressed and canonical #7481 native tape, full application receipt and inherited tariff. It checks the six literal events, strict nested chart spans, both live endpoint banks, exact owned donor covector, rank and directed price. The independent engine walks the original literal scalar tape forward with the separator and the zero control, tracking every chart and live owned field and checking the guarded COPY. It confirms zero bank rows, donor one and old signed increment −1/2. + +The first solve completed in 0.31 seconds and the independent replay in 0.22 seconds. Both completed their one-case scope and exited zero under separate 30-second guards. The wrapper authenticates every named input, requires exact agreement with both receipts and checks that a changed word, duplicate pin or changed signed output fails. The standalone replay requires CPython 3.12 and POSIX. It uses no Git or network dependency. diff --git a/research/p104-role1501-owned-move-fusion-bound/VERIFY.json b/research/p104-role1501-owned-move-fusion-bound/VERIFY.json new file mode 100644 index 0000000000..2c602fefd7 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Verify both exact endpoint spans, the owned donor covector, signed forward separator and directed paid tariff.", + "timeout_seconds": 65 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-role1501-owned-move-fusion-bound/fuse_1501.py b/research/p104-role1501-owned-move-fusion-bound/fuse_1501.py new file mode 100644 index 0000000000..2ec9da63be --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/fuse_1501.py @@ -0,0 +1,81 @@ +"""Exact support check for one owned monotone route fusion.""" +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import alarm + +ROOT = Path(__file__).resolve().parent + + +def dot(row, probe): + return sum(coefficient * probe.get(key, 0) for key, coefficient in row.items()) + + +def span(vectors): + result = {0} + for vector in vectors: + result |= {value ^ vector for value in result} + return result + + +def main(): + assert __debug__ + alarm(30) + helper = ROOT / 'gate.py' + assert sha256(helper.read_bytes()).hexdigest() == 'aa13cd2797877ef7328d5bcda24be51815fddcc4e8ae091382ad963fb978e5e9' + model = run_path(str(helper)) + names = ['7481-WORD.json.gz', '7481-APPLICATION.json', 'pricing.py'] + data = {name: (ROOT / name).read_bytes() for name in names} + assert all(sha256(raw).hexdigest() == model['PINS'][name] for name, raw in data.items()) + payload = decompress(data[names[0]]) + assert sha256(payload).hexdigest() == '64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8' + word = loads(payload) + tape = word['program'] + assert tape[40563:40569] == [ + ['MOVE',1501,549,115,True], ['ADD',1501,1525,'1/4',115], ['CLEAR',1525,115], + ['MOVE',174,3,593,False], ['MOVE',1501,115,593,True], ['ADD',174,1501,'-2',593], + ] + frames = [word['frames'][chart] for chart in (549,115,593)] + assert list(map(len,frames)) == [7,5,1] and span(frames[2]) < span(frames[1]) < span(frames[0]) + rows, basis, represent, census = (model[name] for name in + ('exact_cut_rows', 'basis', 'representation', 'census')) + points = [(40563,549),(40567,593)] + banks = [] + fixed = [] + for cut,chart in points: + _, live, _ = census(word,cut) + bank = sorted(role for role,frame in live.items() if frame == chart) + banks.append(bank) + fixed.extend(rows(tape[:cut],bank,word['public'])) + target, = rows(tape[:40564],[1525],word['public']) + assert target == {607:Q(-1),770:Q(1)} + pivots = basis(fixed) + residual,_ = represent(pivots,target) + probe = None + if residual: + free = min(residual) + assert free not in pivots + probe = {free: 1 / residual[free]} + for column,(row,_) in sorted(pivots.items(),reverse=True): + value = -dot(row,probe) + if value: + probe[column] = value + assert not any(dot(row,probe) for row in fixed) and dot(target,probe) == 1 + lo,hi = map(Q,loads(data[names[1]])['directed_crossing_bracket']) + price = run_path(str(ROOT / names[2]))['power_bounds'] + gross = [17*(price(2,hi)[0]+price(4,hi)[0]-price(6,lo)[1]), + 17*(price(2,lo)[1]+price(4,lo)[1]-price(6,hi)[0])] + assert Q('.2355') < gross[0] <= gross[1] < Q('.2356') + print(dumps({'status':'LOCAL_FUSION_EXCLUDED' if probe else 'SUPPORT_GATE_SURVIVES', + 'case_cap':1,'runner_cap_seconds':30,'banks':banks,'points':points, + 'target':target,'probe':probe,'bank_rank':len(pivots), + 'union_rank':len(basis(fixed+[target])), 'whole_signed_gross':gross}, + sort_keys=True,indent=2,default=str)) + alarm(0) + + +if __name__ == '__main__': + main() diff --git a/research/p104-role1501-owned-move-fusion-bound/gate.py b/research/p104-role1501-owned-move-fusion-bound/gate.py new file mode 100644 index 0000000000..cb01ba3671 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/gate.py @@ -0,0 +1,203 @@ +"""Replay one #7481 owned-to-productive restoration gate, with exact arithmetic.""" +from collections import Counter +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path +from signal import alarm + +ROOT = Path(__file__).resolve().parent +PINS = { + '7481-WORD.json.gz': 'acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9', + '7113-CALLER.json': '255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', + '7481-APPLICATION.json': '1d93fae969ff24ecb91bb4bee6af74daaa9ea99141bcf630a77eeb1a167b1799', + 'pricing.py': 'f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182', +} +ROLE, START, CUT = 1533, 38139, 42503 + + +def add(row, j, coefficient): + result = row.get(j, Q(0)) + coefficient + if result: + row[j] = result + else: + row.pop(j, None) + + +def exact_cut_rows(tape, roles, public): + out = [] + for role in roles: + row = {role: Q(1)} + for op, dest, *args in reversed(tape): + if dest not in row or op == 'MOVE': + continue + factor = row[dest] + if op in ('INIT', 'CLEAR', 'COPY'): + del row[dest] + if op == 'SCALE': + row[dest] *= Q(args[0]) + if op in ('ADD', 'COPY'): + add(row, args[0], Q(args[1]) * factor) + assert all(j < public for j in row) + out.append(row) + return out + + +def column(tape, start, cut, role): + live = {role: Q(1)} + dirty_guards = [] + for clock in range(start + 1, cut): + op, dest, *args = tape[clock] + if op == 'MOVE': + continue + if op in ('INIT', 'CLEAR', 'COPY'): + before = live.pop(dest, Q(0)) + if before and op in ('INIT', 'COPY'): + dirty_guards.append((clock, op, dest, str(before))) + if op in ('ADD', 'COPY') and args[0] in live: + add(live, dest, Q(args[1]) * live[args[0]]) + if op == 'SCALE' and dest in live: + live[dest] *= Q(args[0]) + return live, dirty_guards + + +def basis(rows): + pivots = {} + for i, source in enumerate(rows): + row = source.copy() + coeff = {i: Q(1)} + for pivot, (vector, origin) in sorted(pivots.items()): + if pivot in row: + scale = row[pivot] + for j, val in vector.items(): + add(row, j, -scale * val) + for j, val in origin.items(): + add(coeff, j, -scale * val) + if row: + pivot = min(row) + scale = row[pivot] + pivots[pivot] = ({j: val / scale for j, val in row.items()}, + {j: val / scale for j, val in coeff.items()}) + return pivots + + +def representation(pivots, target): + row = target.copy() + coeff = {} + for pivot, (vector, origin) in sorted(pivots.items()): + if pivot in row: + scale = row[pivot] + for j, val in vector.items(): + add(row, j, -scale * val) + for j, val in origin.items(): + add(coeff, j, scale * val) + return (row, coeff) + + +def census(word, cut): + active = dict(enumerate(word['initial'])) + owned = {} + lifetimes = [] + paid = Counter() + cut_roles = None + ranks = list(map(len, word['frames'])) + for clock, (op, dest, *args) in enumerate(word['program']): + if clock == cut: + cut_roles = active.copy() + if op == 'INIT': + assert dest not in active + owned[dest] = (clock, args[0], []) + active[dest] = args[0] + elif op == 'CLEAR': + start, chart, moves = owned.pop(dest) + assert active.pop(dest) == args[0] + gain = ranks[args[0]] - ranks[chart] + if gain > 0 and all(d > 0 for _, _, _, d in moves): + assert gain == sum(d for _, _, _, d in moves) + lifetimes.append((dest, start, clock, chart, args[0], gain, moves)) + elif op == 'MOVE': + before, after, owned_flag = args + assert active[dest] == before and (dest in owned) == owned_flag + delta = ranks[after] - ranks[before] + assert delta + paid[abs(delta)] += 1 + active[dest] = after + if owned_flag: + owned[dest][2].append((clock, before, after, delta)) + elif op in ('ADD', 'COPY'): + assert active[dest] == active[args[0]] == args[-1] + else: + assert op == 'SCALE' and active[dest] == args[-1] + assert not owned and list(active.values()) == word['final'] + assert sum(paid.values()) == 6279 + return lifetimes, cut_roles, paid + + +def main(): + assert __debug__ + alarm(30) + inputs = {name: (ROOT / name).read_bytes() for name in PINS} + assert {k: sha256(v).hexdigest() for k, v in inputs.items()} == PINS + w = json.loads(gzip.decompress(inputs['7481-WORD.json.gz'])) + caller = json.loads(inputs['7113-CALLER.json']) + app = json.loads(inputs['7481-APPLICATION.json']) + power_bounds = run_path(str(ROOT / 'pricing.py'))['power_bounds'] + tape = w['program'] + public = w['public'] + assert len(tape) == 76475 and public == 1501 + assert caller['stages'] == sum(event[0] == 'J' for event in caller['events']) == 17 + assert tape[START] == ['INIT', ROLE, 597] and tape[CUT] == ['CLEAR', ROLE, 591] + lifetimes, active, paid = census(w, CUT) + assert len(lifetimes) == 19 and sum(entry[5] for entry in lifetimes) == 56 + lead, = [entry for entry in lifetimes if entry[0] == ROLE and entry[1] == START] + assert lead[2:] == (CUT, 597, 591, 7, [(42487, 597, 1031, 4), (42500, 1031, 591, 3)]) + peers = tuple(sorted(q for q, chart in active.items() if chart == 591)) + assert peers == (133, 697, 767, 901, 1334, 1377, ROLE) + assert not any(f == 591 for f in w['final']) + lo, hi = map(Q, app['directed_crossing_bracket']) + assert Q(0) < lo < hi < 1 + gross = (17 * power_bounds(7, hi)[0], 17 * power_bounds(7, lo)[1]) + whole = sum(17 * power_bounds(lead[5], lo)[1] for lead in lifetimes) + assert 0 < gross[0] <= gross[1] < 119 and whole < 952 + assert app['paid_calls'] == 110519 and app['productive_calls'] == 22461 and app['surplus'] == 1424 + live, guards = column(tape, START, CUT, ROLE) + assert set(live) <= set(active) + exterior = {q: value for q, value in live.items() if q not in peers} + controls = [(['INIT', 3, 0], ['ADD', 2, 3, '2', 0], ['CLEAR', 3, 0]), + (['INIT', 3, 0], ['COPY', 3, 2, '2', 0], ['CLEAR', 3, 0])] + assert column(controls[0], 0, 2, 3) == ({2: Q(2), 3: Q(1)}, []) + assert column(controls[1], 0, 2, 3) == ({}, [(1, 'COPY', 3, '1')]) + necessary = not exterior and not guards + restoration = None + if necessary: + rows = exact_cut_rows(tape[:CUT], peers, public) + raised = [row.copy() for row in rows] + for q, row in zip(peers, raised): + add(row, public, live.get(q, Q(0))) + target = [row for q, row in zip(peers, rows) if q != ROLE] + [{public: Q(1)}] + old_rank = len(basis(raised)) + new_rank = len(basis(target)) + union_rank = len(basis(raised + target)) + pivots = basis(raised) + representations = [representation(pivots, row) for row in target] + restoration = {'source_rank': old_rank, 'restored_rank': new_rank, 'union_rank': union_rank, + 'unsupported': sum(bool(remainder) for remainder, _ in representations), + 'rational_representations': [coeff for _, coeff in representations]} + necessary = old_rank == new_rank == union_rank + alarm(0) + print(json.dumps({ + 'case_cap': 1, 'runner_cap_seconds': 30, 'cases_completed': 1, + 'pins': PINS, 'lifetime': lead, 'coframe': peers, 'stock_count': len(lifetimes), + 'stock_rank': 56, 'local_paid': dict(sorted(paid.items())), 'changed_full_paid': {}, + 'changed_full_productive': {7: 17}, 'changed_full_rank_surplus': 119, + 'gross_range': list(gross), 'whole_stock_optimistic_upper': whole, + 'cut_dirty_column': dict(sorted(live.items())), 'exterior_dirty_column': dict(sorted(exterior.items())), + 'dirty_guards': guards, 'restoration': restoration, 'necessary_survived': necessary, + 'status': 'NECESSARY_GATE_SURVIVES_DYADIC_AND_PHYSICAL_REPLAY_PENDING' if necessary else 'EXACT_FIXED_CUT_EXCLUSION', + }, indent=2, sort_keys=True, default=str)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-role1501-owned-move-fusion-bound/pricing.py b/research/p104-role1501-owned-move-fusion-bound/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/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-role1501-owned-move-fusion-bound/receipts/DENSE.json b/research/p104-role1501-owned-move-fusion-bound/receipts/DENSE.json new file mode 100644 index 0000000000..7d24d09ad2 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/receipts/DENSE.json @@ -0,0 +1,34 @@ +{ + "bank_roles": [ + [ + 111, + 121, + 173, + 235, + 752, + 881, + 891, + 937, + 999, + 1501, + 1522 + ], + [ + 174, + 469, + 549, + 561, + 1254, + 1530 + ] + ], + "inputs": { + "10": "-1", + "173": "-1/2", + "607": "-1" + }, + "old_outward_increment": "-1/2", + "owned_donor": "1", + "status": "PASS_LITERAL_FORWARD_SEPARATOR", + "zero_control": true +} diff --git a/research/p104-role1501-owned-move-fusion-bound/receipts/SPARSE.json b/research/p104-role1501-owned-move-fusion-bound/receipts/SPARSE.json new file mode 100644 index 0000000000..7535139abb --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/receipts/SPARSE.json @@ -0,0 +1,53 @@ +{ + "bank_rank": 15, + "banks": [ + [ + 111, + 121, + 173, + 235, + 752, + 881, + 891, + 937, + 999, + 1501, + 1522 + ], + [ + 174, + 469, + 549, + 561, + 1254, + 1530 + ] + ], + "case_cap": 1, + "points": [ + [ + 40563, + 549 + ], + [ + 40567, + 593 + ] + ], + "probe": { + "10": "-1", + "173": "-1/2", + "607": "-1" + }, + "runner_cap_seconds": 30, + "status": "LOCAL_FUSION_EXCLUDED", + "target": { + "607": "-1", + "770": "1" + }, + "union_rank": 16, + "whole_signed_gross": [ + "1177939222631322442486545079717204883411438871457/5000000000000000000000000000000000000000000000000", + "2355878445262644884973090159434708636015487878117/10000000000000000000000000000000000000000000000000" + ] +} diff --git a/research/p104-role1501-owned-move-fusion-bound/replay.py b/research/p104-role1501-owned-move-fusion-bound/replay.py new file mode 100644 index 0000000000..fba4564b14 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/replay.py @@ -0,0 +1,78 @@ +"""Authenticate and replay the exact role-1501 owned move fusion bound.""" +from fractions import Fraction +from hashlib import sha256 +from json import loads +from pathlib import Path +from subprocess import run +from sys import executable, implementation, version_info + +ROOT = Path(__file__).resolve().parent +FILES = { + "7481-WORD.json.gz", "7481-APPLICATION.json", "gate.py", "pricing.py", + "fuse_1501.py", "verify_fusion_probe.py", "PROVENANCE.json", + "receipts/SPARSE.json", "receipts/DENSE.json", +} + + +def unique(pairs): + result = dict(pairs) + assert len(result) == len(pairs), "duplicate JSON key" + return result + + +def parse(raw): + return loads(raw, object_pairs_hook=unique) + + +def check(raw, digest): + assert sha256(raw).hexdigest() == digest, "changed bytes" + + +def compare(sparse, dense): + assert sparse["status"] == "LOCAL_FUSION_EXCLUDED" + assert sparse["case_cap"] == 1 and sparse["runner_cap_seconds"] == 30 + assert sparse["points"] == [[40563, 549], [40567, 593]] + assert sparse["banks"] == dense["bank_roles"] + assert sparse["bank_rank"] == 15 and sparse["union_rank"] == 16 + assert sparse["target"] == {"607": "-1", "770": "1"} + assert sparse["probe"] == dense["inputs"] == {"10": "-1", "173": "-1/2", "607": "-1"} + assert dense["status"] == "PASS_LITERAL_FORWARD_SEPARATOR" + assert dense["owned_donor"] == "1" and dense["old_outward_increment"] == "-1/2" + assert dense["zero_control"] is True + low, high = map(Fraction, sparse["whole_signed_gross"]) + assert Fraction("0.2355") < low <= high < Fraction("0.2356") + + +def expect_failure(action): + try: + action() + except AssertionError: + return + raise AssertionError("mutated input or receipt passed") + + +def main(): + assert __debug__ and implementation.name == "cpython" and version_info[:2] == (3, 12) + pins = parse((ROOT / "PINS.json").read_bytes()) + assert set(pins) == FILES + inputs = {name: (ROOT / name).read_bytes() for name in sorted(FILES)} + for name, raw in inputs.items(): + check(raw, pins[name]) + outputs = [] + for engine, receipt in (("fuse_1501.py", "SPARSE.json"), ("verify_fusion_probe.py", "DENSE.json")): + result = run([executable, "-I", "-B", str(ROOT / engine)], check=True, + capture_output=True, timeout=31) + actual = parse(result.stdout) + assert actual == parse(inputs[f"receipts/{receipt}"]) + outputs.append(actual) + sparse, dense = outputs + compare(sparse, dense) + word = inputs["7481-WORD.json.gz"] + expect_failure(lambda: check(bytes([word[0] ^ 1]) + word[1:], pins["7481-WORD.json.gz"])) + expect_failure(lambda: parse('{"word":0,"word":1}')) + expect_failure(lambda: compare(sparse, dict(dense, old_outward_increment="1/2"))) + print("PASS_ROLE1501_OWNED_MOVE_FUSION: one exact case, zero survivors, signed separator verified") + + +if __name__ == "__main__": + main() diff --git a/research/p104-role1501-owned-move-fusion-bound/verify_fusion_probe.py b/research/p104-role1501-owned-move-fusion-bound/verify_fusion_probe.py new file mode 100644 index 0000000000..6a0fc630b9 --- /dev/null +++ b/research/p104-role1501-owned-move-fusion-bound/verify_fusion_probe.py @@ -0,0 +1,67 @@ +"""Literal forward check of one normalized input separating the owned route fusion.""" +from fractions import Fraction +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from signal import alarm + +SOURCE = Path(__file__).with_name('7481-WORD.json.gz') + + +def replay(word, probe): + values = [probe.get(role, Fraction()) for role in range(word['public'])] + [None]*word['owned_fields'] + frames = word['initial'] + [None]*word['owned_fields'] + observations = {} + for clock, (op, dst, *args) in enumerate(word['program'][:40569]): + if clock in (40563,40567): + chart = 549 if clock == 40563 else 593 + observations[clock] = {role: values[role] for role,frame in enumerate(frames) if frame==chart} + if clock == 40564: + observations['owned_donor'] = values[1525] + if clock == 40568: + observations['old_outward_increment'] = -2*values[1501] + if op == 'INIT': + assert values[dst] is None and frames[dst] is None + values[dst],frames[dst] = Fraction(),args[0] + elif op == 'CLEAR': + assert frames[dst] == args[0] + values[dst],frames[dst] = None,None + elif op == 'MOVE': + assert frames[dst] == args[0] and (dst >= word['public']) == args[2] + frames[dst] = args[1] + elif op == 'SCALE': + assert frames[dst] == args[1] + values[dst] *= Fraction(args[0]) + else: + src,coefficient,chart = args + assert op in ('ADD','COPY') and frames[dst] == frames[src] == chart + if op == 'COPY': + assert not values[dst] + values[dst] += Fraction(coefficient)*values[src] + return observations + + +def main(): + assert __debug__ + alarm(30) + blob = SOURCE.read_bytes() + assert sha256(blob).hexdigest() == 'acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' + raw = decompress(blob) + assert sha256(raw).hexdigest() == '64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8' + word = loads(raw) + probe = {10:Fraction(-1),173:Fraction(-1,2),607:Fraction(-1)} + result = replay(word,probe) + zero = replay(word,{}) + assert all(result[clock]==zero[clock] and not any(result[clock].values()) for clock in (40563,40567)) + assert result['owned_donor'] == 1 and result['old_outward_increment'] == Fraction(-1,2) + assert zero['owned_donor'] == zero['old_outward_increment'] == 0 + print(dumps({'status':'PASS_LITERAL_FORWARD_SEPARATOR','inputs':probe, + 'bank_roles':[sorted(result[clock]) for clock in (40563,40567)], + 'owned_donor':result['owned_donor'],'old_outward_increment':result['old_outward_increment'], + 'zero_control':True},default=str,sort_keys=True,indent=2)) + alarm(0) + + +if __name__ == '__main__': + main()