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-role235-paid-bypass-bound/7481-APPLICATION.json b/research/p104-role235-paid-bypass-bound/7481-APPLICATION.json new file mode 100644 index 0000000000..28390c8bb4 --- /dev/null +++ b/research/p104-role235-paid-bypass-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-role235-paid-bypass-bound/7481-WORD.json.gz b/research/p104-role235-paid-bypass-bound/7481-WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-role235-paid-bypass-bound/7481-WORD.json.gz differ diff --git a/research/p104-role235-paid-bypass-bound/NOTICE.md b/research/p104-role235-paid-bypass-bound/NOTICE.md new file mode 100644 index 0000000000..1b1f0318e3 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/NOTICE.md @@ -0,0 +1 @@ +Apache-2.0. #7481 supplies the exact word, application crossing and funded bypass precedent. #7480 and #7334 supply the retained native construction lineage. #7113 supplies the complete signed caller multiplicity. #7482 supplies the rational tape and rank routines. #7362 supplies directed tariff arithmetic. OpenAI Codex and subagents materially assisted design, proof, implementation, independent replay and packaging. diff --git a/research/p104-role235-paid-bypass-bound/PINS.json b/research/p104-role235-paid-bypass-bound/PINS.json new file mode 100644 index 0000000000..9dcc652834 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/PINS.json @@ -0,0 +1,12 @@ +{ + "7481-APPLICATION.json": "1d93fae969ff24ecb91bb4bee6af74daaa9ea99141bcf630a77eeb1a167b1799", + "7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "PROVENANCE.json": "be42d7f455cf004d5c34afdc67c120d98772d9804e421bbf8c7c216d359e0f99", + "gate.py": "aa13cd2797877ef7328d5bcda24be51815fddcc4e8ae091382ad963fb978e5e9", + "gate235.py": "046dbbb428f35a0435c61825a137c6e2b41a9059419e792505c25c691740c982", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/DENSE.json": "ac9988861b0e85d73f514a589ad424f91b0dd3824c12d7f31dc458bb8e93a68b", + "receipts/SEPARATOR.json": "1a303ceff987024d44c6797980a22ebf04ec66bd49b6af82d83f578326dc1398", + "receipts/SPARSE.json": "6eb5d8571aa120a0fa50d6c6b12e393232c853b44537a81841e769d3771e0c11", + "verify_separator.py": "5ae99f9a4071daea65ecccb2af9a27aa5dcfbd36aa84f4e902d6ce1aef77d177" +} diff --git a/research/p104-role235-paid-bypass-bound/PROOF.md b/research/p104-role235-paid-bypass-bound/PROOF.md new file mode 100644 index 0000000000..50dea1ab90 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/PROOF.md @@ -0,0 +1,9 @@ +# Fixed chart-549 read prevents a paid bypass for role 235 + +The source is [#7481 at 89eaa9d8cae37c1540de98f2d29a3abaabb96a2b](https://github.com/CrocSwap/integer-mult-bounds/pull/7481) with [the signed #7113 caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113). The three literal zero-based events are MOVE39248, ADD39249 and MOVE46996. Role 235 visits nested binary charts 550 → 549 → 127 at ranks 3, 7 and 9. It is the source for the sole intervening contact `173 += −235/2` at chart 549. The candidate leaves role 235 at chart 550 until its old exit and replaces its two paid moves with a direct rank-six move. + +At ADD39249 the coframed bank that remains after removing role 235 is 173, 881, 937, 999 and owned role 1549. Its exact rational rank is four. Including the original source row raises the rank to five. Set arbitrary public input 7 to one and all other public inputs to zero. Every remaining bank row then equals zero, while role 235 equals one. On the zero input the bank rows are again zero. The required ADD increments are −1/2 and zero on the two inputs respectively. The fixed local correction therefore cannot produce the required old row of role 173. The decision permits arbitrary rational combinations of all remaining rows, including the owned row. A coframed scratch initialized to zero supplies no dependence on this old input. + +The two paid ranks 4 and 2 would have been replaced by rank 6, for signed paid delta {2:−17, 4:−17, 6:+17}. All productive calls stay fixed. Directed arithmetic on the exact #7481 crossing brackets the optimistic full signed saving strictly between 0.2355 and 0.2356 raw. The declared splice has no extra paid move, route, ownership change or restoration charge. One extra charged native position costs at least 17 raw across the fixed caller. A full construction would still require arbitrary-input restoration, ordinary scalar, tape, precision and absolute physical map verification. The excluded case realizes zero saving. + +#7481 uses a second public role to finance a different bypass. This case holds the bank and all other itineraries fixed. The charged-readout pilot in Discussion #7111 concerns a different two-channel construction with one declared charged route. The literal clocks and fixed-bank contract here are distinct from those scopes. diff --git a/research/p104-role235-paid-bypass-bound/PROVENANCE.json b/research/p104-role235-paid-bypass-bound/PROVENANCE.json new file mode 100644 index 0000000000..415615514d --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/PROVENANCE.json @@ -0,0 +1,26 @@ +{ + "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.", + "7334": "Earlier complete signed comparator and retained native layout.", + "7362": "Directed tariff arithmetic in pricing.py.", + "7480": "Preceding return construction and unchanged signing lineage.", + "7481": "Exact active word, application and funded public bypass.", + "7482": "Exact rational tape and row rank routines in gate.py." + }, + "schema_version": 1 +} diff --git a/research/p104-role235-paid-bypass-bound/README.md b/research/p104-role235-paid-bypass-bound/README.md new file mode 100644 index 0000000000..f603f1b23e --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/README.md @@ -0,0 +1,15 @@ +# Bound the chart-549 paid bypass for role 235 + +**NO VERIFIED GAIN.** The exact [#7481](https://github.com/CrocSwap/integer-mult-bounds/pull/7481) native tape uses role 235 at chart 549 between paid ranks four and two. A rank-six direct move would save strictly between 0.2355 and 0.2356 raw across the complete signed caller. At the old ADD, the retained bank annihilates the public unit input in role 7, while the original source has value one. The old ADD is impossible to reconstruct from that bank. + +One role and one fixed cut were exhausted. From a clean POSIX checkout with CPython 3.12 and assertions enabled, run: + +```sh +python3.12 -I -B research/p104-role235-paid-bypass-bound/replay.py +``` + +[Proof and exact scope](PROOF.md) · [Verification](VERIFICATION.md) · [Source pins and credit](PROVENANCE.json) + +## Open next questions + +Different capture clocks or transport of an additional independent row can change the span. Their complete price must be checked before construction. A new paid rank-one position alone costs 17 raw under the retained caller and exceeds this case's gross gain. This bound leaves changed bank itineraries and paid exchanges outside its scope. diff --git a/research/p104-role235-paid-bypass-bound/SOURCES.json b/research/p104-role235-paid-bypass-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-role235-paid-bypass-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-role235-paid-bypass-bound/TASK.json b/research/p104-role235-paid-bypass-bound/TASK.json new file mode 100644 index 0000000000..84226008cc --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7481 role 235, MOVE39248, ADD39249 and MOVE46996. Fixed chart-549 read and other bank rows, fixed productive endpoints and signed caller.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 role 235 fixed-bank paid bypass", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "A nested direct rank-six move replaces paid ranks four and two if the fixed read can be restored. This removes paid complex moment without changing productive endpoints.", + "budget_minutes": 10, + "evidence": "Exact reverse rank increases from four to five and an independent dense signed replay verifies the public x7 separator at the sole intervening ADD.", + "open_questions": [ + { + "blocked_by": "The surviving chart-549 bank annihilates public input x7, while the old ADD requires it.", + "first_step": "A changed bank must provide an independent input direction with its complete paid and restoration invoice.", + "question": "Can a different fixed-price bank or joint paid exchange preserve this read?", + "why_it_matters": "The declared direct bypass would strictly reduce 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": "Change two paid public MOVEs into one while fixing productive endpoints and solving the sole local signed ADD with the existing consumer bank.", + "scope_status": "changed", + "stop_rule": "Exactly one role, one cut and one retained bank, capped at 30 seconds per engine. Stop after a rank or signed separator decision.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-role235-paid-bypass-bound/VERIFICATION.md b/research/p104-role235-paid-bypass-bound/VERIFICATION.md new file mode 100644 index 0000000000..6b26d17482 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/VERIFICATION.md @@ -0,0 +1,5 @@ +# Verification + +The runner authenticates the compressed and canonical exact #7481 tape and the full application receipt, validates both old moves and the only intervening role-235 contact, reconstructs the entire native paid histogram and proves nested frame spans. It computes the old bank covectors by a backward rational pass. An independent forward evaluator checks the separating old input, its negation and the zero input through the literal signed tape, including chart and ownership invariants. The separating input yields an old ADD contribution of −1/2. The lead solved one case in 0.21 seconds and the forward replay passed in 0.25 seconds under separate 30-second guards. Both exits were 0. + +The wrapper checks package-relative byte pins, requires exact agreement with both frozen receipts, and verifies that a changed word, duplicate pin or changed signed outward contribution fails. CPython 3.12 and POSIX are required. The direct replay needs neither Git nor network access. diff --git a/research/p104-role235-paid-bypass-bound/VERIFY.json b/research/p104-role235-paid-bypass-bound/VERIFY.json new file mode 100644 index 0000000000..f75795c50b --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/VERIFY.json @@ -0,0 +1,14 @@ +{ + "commands": [ + { + "argv": ["{python}", "-I", "-B", "{package}/replay.py"], + "checks": "Authenticate the exact #7481 word and application, replay the exact cut rank and directed price, and verify the signed forward separator.", + "timeout_seconds": 70 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-role235-paid-bypass-bound/gate.py b/research/p104-role235-paid-bypass-bound/gate.py new file mode 100644 index 0000000000..cb01ba3671 --- /dev/null +++ b/research/p104-role235-paid-bypass-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-role235-paid-bypass-bound/gate235.py b/research/p104-role235-paid-bypass-bound/gate235.py new file mode 100644 index 0000000000..2836aae8e2 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/gate235.py @@ -0,0 +1,118 @@ +"""Check one paid bypass and its unchanged chart-549 read on exact #7481.""" +from fractions import Fraction +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 +WORD_PIN = "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" +CANONICAL_PIN = "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8" +APPLICATION_PIN = "1d93fae969ff24ecb91bb4bee6af74daaa9ea99141bcf630a77eeb1a167b1799" +PRICING_PIN = "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182" +GATE_PIN = "aa13cd2797877ef7328d5bcda24be51815fddcc4e8ae091382ad963fb978e5e9" +ROLE, ENTRY, READ, EXIT = 235, 39248, 39249, 46996 + + +def pin(name, digest): + raw = (ROOT / name).read_bytes() + assert sha256(raw).hexdigest() == digest, name + return raw + + +def span(frame): + seen = {0} + for column in frame: + assert column not in seen + seen |= {column ^ old for old in seen} + return seen + + +def value(row, assignment): + return sum(c * assignment.get(j, 0) for j, c in row.items()) + + +def main(): + assert __debug__ + alarm(30) + raw = decompress(pin("7481-WORD.json.gz", WORD_PIN)) + assert sha256(raw).hexdigest() == CANONICAL_PIN + word = loads(raw) + app = loads(pin("7481-APPLICATION.json", APPLICATION_PIN)) + pin("pricing.py", PRICING_PIN) + pin("gate.py", GATE_PIN) + price = run_path(str(ROOT / "pricing.py"))["power_bounds"] + helpers = run_path(str(ROOT / "gate.py")) + tape = word["program"] + assert tape[ENTRY] == ["MOVE", ROLE, 550, 549, False] + assert tape[READ] == ["ADD", 173, ROLE, "-1/2", 549] + assert tape[EXIT] == ["MOVE", ROLE, 549, 127, False] + touches = [clock for clock in range(ENTRY + 1, EXIT) + if tape[clock][1] == ROLE or ( + tape[clock][0] in {"ADD", "COPY"} and tape[clock][2] == ROLE)] + assert touches == [READ] + first, middle, last = (word["frames"][chart] for chart in (550, 549, 127)) + assert span(first) < span(middle) < span(last) + assert (len(first), len(middle), len(last)) == (3, 7, 9) + _, live, old_paid = helpers["census"](word, READ) + bank = sorted(role for role, chart in live.items() if chart == 549 and role != ROLE) + assert bank == [173, 881, 937, 999, 1549] + old_rows = helpers["exact_cut_rows"](tape[:READ], bank + [ROLE], word["public"]) + bank_rows, read_row = old_rows[:-1], old_rows[-1] + assert bank_rows[-1] == {} + pivots = helpers["basis"](bank_rows) + missing, coefficients = helpers["representation"](pivots, read_row) + known_row, _ = helpers["representation"](pivots, bank_rows[0]) + assert not known_row + witness = None + if missing: + index = min(missing) + assert index not in pivots + witness = {index: Fraction(1)} + for pivot, (row, _) in sorted(pivots.items(), reverse=True): + assert row[pivot] == 1 and min(row) == pivot + result = -sum(c * witness.get(j, 0) for j, c in row.items() if j != pivot) + if result: + witness[pivot] = result + assert all(value(row, witness) == 0 for row in bank_rows) + assert value(read_row, witness) != 0 + else: + assert all(read_row.get(j, 0) == sum( + coef * bank_rows[i].get(j, 0) for i, coef in coefficients.items() + ) for j in range(word["public"])) + low, high = map(Fraction, app["directed_crossing_bracket"]) + lower = 17 * (price(4, high)[0] + price(2, high)[0] - price(6, low)[1]) + upper = 17 * (price(4, low)[1] + price(2, low)[1] - price(6, high)[0]) + assert Fraction("0.2355") < lower <= upper < Fraction("0.2356") + new_paid = dict(old_paid) + new_paid[2] -= 1 + new_paid[4] -= 1 + new_paid[6] += 1 + result = { + "decision": "excluded at fixed bank" if missing else "rational span survives", + "completed_cases": 1, + "runner_cap_seconds": 30, + "word_sha256": WORD_PIN, + "role": ROLE, + "clocks": [ENTRY, READ, EXIT], + "charts": [550, 549, 127], + "bank": bank, + "bank_rank": len(pivots), + "union_rank": len(helpers["basis"](old_rows)), + "exact_separating_old_input": witness, + "separating_read_value": None if witness is None else value(read_row, witness), + "rational_coefficients_by_bank_role": None if missing else { + bank[i]: coefficient for i, coefficient in coefficients.items()}, + "optimistic_signed_saving": [lower, upper], + "conditional_native_paid_histogram": new_paid, + "conditional_signed_paid_delta": {2: -17, 4: -17, 6: 17}, + "conditional_signed_productive_delta": {}, + } + alarm(0) + print(dumps(result, default=str, sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-role235-paid-bypass-bound/pricing.py b/research/p104-role235-paid-bypass-bound/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-role235-paid-bypass-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-role235-paid-bypass-bound/receipts/DENSE.json b/research/p104-role235-paid-bypass-bound/receipts/DENSE.json new file mode 100644 index 0000000000..ee99b8567c --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/receipts/DENSE.json @@ -0,0 +1,17 @@ +{ + "bank": { + "173": "0", + "881": "0", + "937": "0", + "999": "0", + "1549": "0" + }, + "chart": 549, + "cut": 39249, + "old_inputs": { + "7": "1" + }, + "required_old_ADD_delta": "-1/2", + "role": 235, + "status": "EXACT_SIGNED_SEPARATOR" +} diff --git a/research/p104-role235-paid-bypass-bound/receipts/SEPARATOR.json b/research/p104-role235-paid-bypass-bound/receipts/SEPARATOR.json new file mode 100644 index 0000000000..09719d9356 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/receipts/SEPARATOR.json @@ -0,0 +1 @@ +{"7":"1"} diff --git a/research/p104-role235-paid-bypass-bound/receipts/SPARSE.json b/research/p104-role235-paid-bypass-bound/receipts/SPARSE.json new file mode 100644 index 0000000000..d6745e6995 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/receipts/SPARSE.json @@ -0,0 +1,51 @@ +{ + "bank": [ + 173, + 881, + 937, + 999, + 1549 + ], + "bank_rank": 4, + "charts": [ + 550, + 549, + 127 + ], + "clocks": [ + 39248, + 39249, + 46996 + ], + "completed_cases": 1, + "conditional_native_paid_histogram": { + "1": 4001, + "2": 853, + "3": 827, + "4": 221, + "5": 344, + "6": 17, + "7": 10, + "8": 5 + }, + "conditional_signed_paid_delta": { + "2": -17, + "4": -17, + "6": 17 + }, + "conditional_signed_productive_delta": {}, + "decision": "excluded at fixed bank", + "exact_separating_old_input": { + "7": "1" + }, + "optimistic_signed_saving": [ + "1177939222631322442486545079717204883411438871457/5000000000000000000000000000000000000000000000000", + "2355878445262644884973090159434708636015487878117/10000000000000000000000000000000000000000000000000" + ], + "rational_coefficients_by_bank_role": null, + "role": 235, + "runner_cap_seconds": 30, + "separating_read_value": "1", + "union_rank": 5, + "word_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" +} diff --git a/research/p104-role235-paid-bypass-bound/replay.py b/research/p104-role235-paid-bypass-bound/replay.py new file mode 100644 index 0000000000..83dc0e5aa9 --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/replay.py @@ -0,0 +1,80 @@ +"""Authenticate and replay the exact chart-549 paid bypass exclusion.""" +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", "gate235.py", "pricing.py", + "PROVENANCE.json", "verify_separator.py", "receipts/SPARSE.json", "receipts/DENSE.json", + "receipts/SEPARATOR.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, separator): + assert sparse["completed_cases"] == 1 and sparse["runner_cap_seconds"] == 30 + assert sparse["decision"] == "excluded at fixed bank" + assert sparse["bank_rank"] == 4 and sparse["union_rank"] == 5 + assert sparse["exact_separating_old_input"] == dense["old_inputs"] == separator == {"7": "1"} + assert dense["role"] == sparse["role"] == 235 + assert dense["cut"] == sparse["clocks"][1] == 39249 + assert dense["chart"] == sparse["charts"][1] == 549 + assert dense["bank"] == {str(role): "0" for role in sparse["bank"]} + assert dense["status"] == "EXACT_SIGNED_SEPARATOR" + assert Fraction(dense["required_old_ADD_delta"]) == -Fraction(sparse["separating_read_value"]) / 2 + assert sparse["conditional_signed_paid_delta"] == {"2": -17, "4": -17, "6": 17} + assert sparse["conditional_signed_productive_delta"] == {} + low, high = map(Fraction, sparse["optimistic_signed_saving"]) + 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]) + sparse = parse(run([executable, "-I", "-B", str(ROOT / "gate235.py")], check=True, + capture_output=True, timeout=32).stdout) + dense = parse(run([executable, "-I", "-B", str(ROOT / "verify_separator.py"), + str(ROOT / "receipts/SEPARATOR.json")], check=True, + capture_output=True, timeout=32).stdout) + assert sparse == parse(inputs["receipts/SPARSE.json"]) + assert dense == parse(inputs["receipts/DENSE.json"]) + separator = parse(inputs["receipts/SEPARATOR.json"]) + compare(sparse, dense, separator) + 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, required_old_ADD_delta="1/2"), separator)) + print("PASS_ROLE235_PAID_BYPASS: one exact case, zero survivors, signed separator verified") + + +if __name__ == "__main__": + main() diff --git a/research/p104-role235-paid-bypass-bound/verify_separator.py b/research/p104-role235-paid-bypass-bound/verify_separator.py new file mode 100644 index 0000000000..096105ba6a --- /dev/null +++ b/research/p104-role235-paid-bypass-bound/verify_separator.py @@ -0,0 +1,77 @@ +"""Verify the exact role-235 chart-549 separation by literal signed forward action.""" +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 +from sys import argv + +ROOT = Path(__file__).resolve().parent +WORD_HASH = 'acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +RAW_HASH = '64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8' +ROLE, CUT, CHART = 235, 39249, 549 + + +def evaluate(word, assignment): + public = word['public'] + values = [assignment.get(role, Fraction()) for role in range(public)] + [None] * word['owned_fields'] + charts = word['initial'] + [None] * word['owned_fields'] + for clock, (op, role, *args) in enumerate(word['program'][:CUT]): + if op == 'INIT': + assert charts[role] is None and values[role] is None + values[role] = Fraction() + charts[role] = args[0] + elif op == 'CLEAR': + assert charts[role] == args[0] + values[role] = None + charts[role] = None + elif op == 'MOVE': + assert charts[role] == args[0] and (role >= public) == args[2] + charts[role] = args[1] + elif op == 'SCALE': + assert charts[role] == args[1] + values[role] *= Fraction(args[0]) + elif op in ('ADD', 'COPY'): + donor, weight, chart = args + assert charts[role] == charts[donor] == chart + if op == 'COPY': + assert not values[role], (clock, role) + values[role] += Fraction(weight) * values[donor] + else: + raise AssertionError(op) + assert charts[ROLE] == CHART + bank = {role: values[role] for role, chart in enumerate(charts) if chart == CHART and role != ROLE} + return bank, -values[ROLE] / 2 + + +def verify(word, assignment): + bank, contribution = evaluate(word, assignment) + assert set(bank) == {173, 881, 937, 999, 1549} + assert not any(bank.values()) and contribution + return bank, contribution + + +def main(): + assert __debug__ + alarm(30) + payload = (ROOT / '7481-WORD.json.gz').read_bytes() + assert sha256(payload).hexdigest() == WORD_HASH + raw = decompress(payload) + assert sha256(raw).hexdigest() == RAW_HASH + word = loads(raw) + assert word['program'][CUT] == ['ADD', 173, ROLE, '-1/2', CHART] + assignment = {int(role): Fraction(value) for role, value in loads(Path(argv[1]).read_bytes()).items()} + assert all(0 <= role < word['public'] for role in assignment) + bank, contribution = verify(word, assignment) + assert verify(word, {role: -value for role, value in assignment.items()}) == (bank, -contribution) + zero_bank, zero_contribution = evaluate(word, {}) + assert zero_bank == bank and zero_contribution == 0 + print(dumps({'status': 'EXACT_SIGNED_SEPARATOR', 'role': ROLE, 'cut': CUT, 'chart': CHART, + 'old_inputs': assignment, 'bank': bank, 'required_old_ADD_delta': contribution}, + default=str, sort_keys=True, indent=2)) + alarm(0) + + +if __name__ == '__main__': + main()