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-chart922-delayed-bank-separator/NOTICE.md b/research/p104-chart922-delayed-bank-separator/NOTICE.md new file mode 100644 index 0000000000..dfdbd6ac80 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/NOTICE.md @@ -0,0 +1 @@ +The exact source lineage and predecessor credits are in README.md and PROVENANCE.json. OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging. This package is contributed under the repository's Apache-2.0 license. diff --git a/research/p104-chart922-delayed-bank-separator/PINS.json b/research/p104-chart922-delayed-bank-separator/PINS.json new file mode 100644 index 0000000000..b3338ecf5e --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/PINS.json @@ -0,0 +1,9 @@ +{ + "PROVENANCE.json": "589cb5414d37f7a4b853688d3357c0c784e5ef0ddbc09a28eb068a8d919930e5", + "engines/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "engines/scalar.py": "0e0cdcf4af81006d8b9622008b91f142a7c20cf7c0ff19bd23553f9b776fc43b", + "inputs/7334-WORD.json.gz": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "receipts/CERTIFICATE.json": "d028783dbfe11928b5ed017752617f717ef31bea49fc969dc7b428ca450f70eb", + "receipts/INDEPENDENT.json": "fc7b13c43098d203794655d467307ca84ae0c7fdca837d0a60acf7802a08cc36", + "receipts/LEAD.json": "228053a14bc08af9703e318ccfe29a7c95931beb638144360ec3efee0b0c21a4" +} diff --git a/research/p104-chart922-delayed-bank-separator/PROOF.md b/research/p104-chart922-delayed-bank-separator/PROOF.md new file mode 100644 index 0000000000..d7320f66b0 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/PROOF.md @@ -0,0 +1,7 @@ +# Fixed chart-922 correction + +All clocks are zero-based in the #7334 literal word. Target role 185 moves from chart 401 to 1062 at clock 41944. At 41946 it adds `−1/2` times the old source role 82. At 43419 it moves from chart 1062 to 922. There is no other operand contact with role 185 between the first MOVE and the latest cut at 43421. The entrant role 7 moves to chart 922 at 43420, and the next event reads it in an ADD to role 185. + +The tested rewrite would merge the two target MOVEs and synthesize the missing pre-41946 source by rational scalar work on the other live chart-922 fields at cut 43421, keeping the surrounding paid work fixed. Those fields are exactly roles 7, 587, 779, 949 and 960. With all public input coordinates zero except `x1=x2=x311=1`, every one of those five fields evaluates to zero and the old source evaluates to 1. Every linear combination of the available donor rows vanishes on this input. Therefore no combination equals the missing source functional, and multiplying by the old nonzero ADD coefficient does not alter the obstruction. + +The nested frame dimensions are 2, 5 and 7. Even granting the proposed direct quotient, the relaxed invoice gain is only `17*(H(3)+H(2)-H(5))`, with `H(r)=r^(1−κ)`. The outward-rounded interval lies between 0.20766650 and 0.20766651 raw on the pinned #7334 crossing interval. A new paid rank-one position costs 1 and defeats the relaxed quote. The exact span failure already rules out the scoped rewrite before native work. diff --git a/research/p104-chart922-delayed-bank-separator/PROVENANCE.json b/research/p104-chart922-delayed-bank-separator/PROVENANCE.json new file mode 100644 index 0000000000..814e6b5498 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/PROVENANCE.json @@ -0,0 +1,43 @@ +{ + "benchmark": { + "compressed_sha256": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "kappa": "0.00364665195644", + "path": "research/p104-helper-319-fused-return/WORD.json.gz", + "pr": 7334, + "uncompressed_sha256": "9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" + }, + "caller": { + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "pr": 7113 + }, + "predecessors": [ + { + "credit": "Frozen exact latest-cut scope and four previously unresolved cases.", + "head": "41b0a46f906298d847343793ab2eca37516bb980", + "package": "research/p104-one-entrant-delayed-correction-bound", + "pr": 7438 + }, + { + "credit": "Historical bank span and separating-input method.", + "head": "2af3f4d5eb28d2f33db7ddab25503322ba88b5e6", + "pr": 7436 + }, + { + "credit": "Fixed same-owner MOVE chronology and original bank support catalogue.", + "head": "5f45414d0cc5d0ce6931167bc3e54b026fd4ca09", + "pr": 7434 + }, + { + "credit": "Directed rank-power arithmetic.", + "head": "5eec7ed633dcf9b9bbc95552aa653da296f863fb", + "pr": 7362 + }, + { + "credit": "Prior chart-907 result and independently replayable scalar-check structure. Different frozen cut.", + "head": "55b810b6aacebe51b48d5c3a84c8fe162183d53d", + "pr": 7444 + } + ], + "schema_version": 1 +} diff --git a/research/p104-chart922-delayed-bank-separator/README.md b/research/p104-chart922-delayed-bank-separator/README.md new file mode 100644 index 0000000000..29403a08ef --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/README.md @@ -0,0 +1,15 @@ +# Exclude delayed correction from the chart-922 bank + +At the exact [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) word and [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) signed caller, one changed cut left open by [#7438](https://github.com/CrocSwap/integer-mult-bounds/pull/7438) is excluded. This uses the fixed chart-922 bank at cut 43421 for key `[41944,41946,43419]`. The old source evaluates to 1 while all five donors evaluate to zero. The verified saving is zero, and the conditional exponent is unchanged. + +From a clean POSIX checkout with CPython 3.12: + +```sh +python3.12 -I -B research/p104-chart922-delayed-bank-separator/replay.py +``` + +The [proof](PROOF.md) and [verification](VERIFICATION.md) describe the exact local claim, tariff, and rejection control. [#7438](https://github.com/CrocSwap/integer-mult-bounds/pull/7438) supplied the latest-cut model, [#7436](https://github.com/CrocSwap/integer-mult-bounds/pull/7436) the separating-input method, [#7434](https://github.com/CrocSwap/integer-mult-bounds/pull/7434) the original bank inventory, and [#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) the directed rank arithmetic. [#7444](https://github.com/CrocSwap/integer-mult-bounds/pull/7444) supplied a predecessor scalar-replay structure and closed a different cut. + +## Open next questions + +The two remaining changed-cut keys `[40430,40432,46222]` and `[43091,43093,46566]` were outside scope. If revisiting this mechanism, freeze one bank, solve its exact span, and independently replay all donors before any native build. Other donor frames, changes to the paid itinerary, and other correction alphabets are outside the exclusion. diff --git a/research/p104-chart922-delayed-bank-separator/SOURCES.json b/research/p104-chart922-delayed-bank-separator/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/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-chart922-delayed-bank-separator/TASK.json b/research/p104-chart922-delayed-bank-separator/TASK.json new file mode 100644 index 0000000000..6c29094ad7 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113 and one changed cut from #7438. Key [41944,41946,43419], pre-observer cut 43421, target 185, chart 922. Fixed old source and surrounding paid work.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 chart-922 delayed bank audit", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "The positive two-MOVE quote requires synthesizing the old source from the final chart bank without a new paid operation.", + "budget_minutes": 4, + "evidence": "An exact public input evaluates the old source role 82 to 1 before ADD 41946 and all five other live chart-922 roles to zero at cut 43421.", + "open_questions": [ + { + "blocked_by": "Keys [40430,40432,46222] and [43091,43093,46566] were outside scope.", + "first_step": "Choose one remaining key and check the exact span with separate literal scalar verification.", + "question": "Can either remaining changed bank span the fixed old source?", + "why_it_matters": "A span survivor would justify pricing and replaying a paid-itinerary-preserving rewrite." + } + ], + "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": "Resolve one previously unvisited exact delayed chart-bank cut with a literal scalar separating input.", + "scope_status": "changed", + "stop_rule": "One frozen cut, one sparse separating input and its one-component corruption, capped at 20 runner seconds for independent verification. No other keys tested.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-chart922-delayed-bank-separator/VERIFICATION.md b/research/p104-chart922-delayed-bank-separator/VERIFICATION.md new file mode 100644 index 0000000000..521fd518bf --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/VERIFICATION.md @@ -0,0 +1,3 @@ +The lead rational row solve finished in 3.19 seconds under a 30-second cap. A separate literal scalar replay passed in 0.15 seconds under a 20-second cap using the authenticated local word. Its first I/O attempt on a durable replica hit the time limit before any scientific step. The retained word passed both exact SHA-256 checks. + +The scalar replay checks charts, ownership markers and the literal operand chronology along the prefix. Its mutated probe drops `x1`, making the old source zero and donor 779 equal −2. The wrapper independently evaluates both probes on the frozen rational-row receipt and regenerates the full directed quote interval. No other cut was tested. diff --git a/research/p104-chart922-delayed-bank-separator/VERIFY.json b/research/p104-chart922-delayed-bank-separator/VERIFY.json new file mode 100644 index 0000000000..391ac5ad00 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Authenticate the word, replay the exact chart-922 separator and mutant, and check the directed rank quote.", + "timeout_seconds": 40 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-chart922-delayed-bank-separator/engines/pricing.py b/research/p104-chart922-delayed-bank-separator/engines/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/engines/pricing.py @@ -0,0 +1,82 @@ +"""Directed interval arithmetic and the retained signed BIT invoice.""" +from collections import Counter +from fractions import Fraction +from functools import cache + +TARGET = "10018846261809/2500000000000000" +SCALE = 10**49 + + +def rounded(x, upper): + scaled = SCALE*x + if upper: + return Fraction(-((-scaled.numerator) // scaled.denominator), SCALE) + return Fraction(scaled.numerator // scaled.denominator, SCALE) + + +@cache +def log_bounds(x): + z = (x-1)/(x+1) + terms = 60 + exact_partial = 2*sum(z**(2*i+1)/(2*i+1) for i in range(terms)) + tail = 2*z**(2*terms+1)/((2*terms+1)*(1-z*z)) + return rounded(exact_partial, False), rounded(exact_partial+tail, True) + + +@cache +def power_bounds(rank, k): + binary = 2**(rank.bit_length()-1) + shift = binary.bit_length()-1 + l2, u2 = log_bounds(Fraction(2)) + lo, hi = log_bounds(Fraction(rank, binary)) + lo, hi = k*(lo+shift*l2), k*(hi+shift*u2) + assert 0 <= lo <= hi < 1 + + def exponential(z, terms): + total = term = Fraction(1) + for i in range(1, terms+1): + term *= -z/i + total += term + return total + + return rounded(rank*exponential(hi, 35), False), rounded(rank*exponential(lo, 34), True) + + +def cost(hist, k): + lower = upper = Fraction(0) + for r, n in hist.items(): + a, b = (n*x for x in power_bounds(r, k)) + lower += min(a, b) + upper += max(a, b) + return lower, upper + + +def profile(invoice, native, word, ranks): + copies = invoice["native_calls"] + assert copies == len(invoice["native_instances"]) == 36 + assert {tuple((r["stage"], r["copy"])) for r in invoice["native_instances"]} == { + (stage, which) for stage in range(1, 19) for which in (0, 1) + } + assert all(r["ports"] == 111 for r in invoice["native_instances"]) + assert native == Counter({int(r): n for r, n in invoice["native_paid"].items()}) + assert sum(native.values()) == 2871 + caller_paid = {1: 444, **{r: 444 for r in range(7, 57, 7)}} + assert invoice["event_counts"]["QUERY"]*111 == caller_paid[1] + assert invoice["event_counts"]["IDLE_ONE"]*111 == 8*444 + full_paid = Counter({r: copies*n for r, n in native.items()}) + full_paid.update(caller_paid) + + helpers = Counter(ranks[word["final"][j]]-ranks[word["start"][j]] + for j in range(222, word["public"])) + assert helpers == Counter({int(r): n for r, n in invoice["native_helpers"].items()}) + caller_targets = {**{r: 444 for r in range(8, 65, 7)}, 127: 222} + full_targets = Counter({r: copies*n for r, n in helpers.items()}) + full_targets.update(caller_targets) + assert full_paid == Counter({int(r): n for r, n in invoice["paid"].items()}) + assert full_targets == Counter({int(r): n for r, n in invoice["targets"].items()}) + assert sum(full_paid.values()) == invoice["paid_jobs"] + assert sum(full_targets.values()) == invoice["productive_fields"] + signed = full_targets.copy() + signed.subtract(full_paid) + assert sum(r*n for r, n in signed.items()) == invoice["rank_surplus"] + return signed, copies diff --git a/research/p104-chart922-delayed-bank-separator/engines/scalar.py b/research/p104-chart922-delayed-bank-separator/engines/scalar.py new file mode 100644 index 0000000000..92b5f86547 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/engines/scalar.py @@ -0,0 +1,137 @@ +"""Independently check one chart-922 delayed correction against the literal word.""" +from fractions import Fraction as F +from functools import cache +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from signal import SIGALRM, alarm, signal +from sys import argv, implementation, version_info + +HEAD = "aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER = "07a76c5e2738882c0cb322278e56f6cae3c9885d" +COMPRESSED = "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a" +PAYLOAD = "9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" +KEY = [41944, 41946, 43419] +CUT = 43421 +TARGET, SOURCE, CHART = 185, 82, 922 +CAP = 20 + + +def unique(pairs): + result = dict(pairs) + assert len(result) == len(pairs), "duplicate JSON key" + return result + + +def span(vectors): + result = {0} + for value in vectors: + assert value not in result + result |= {value ^ x for x in result} + return result + + +@cache +def scalar(value): + return F(value) + + +def input_map(data, size): + assert all(str(int(k)) == k and 0 <= int(k) < size for k in data) + result = {int(k): F(v) for k, v in data.items()} + assert result and all(result.values()) + return result + + +def tape_check(word, probes): + public, owned = word["public"], word["owned_fields"] + tape = word["program"] + assert (public, owned, len(tape)) == (1501, 68, 76466) + assert [tape[k] for k in KEY] == [ + ["MOVE", TARGET, 401, 1062, False], + ["ADD", TARGET, SOURCE, "-1/2", 1062], + ["MOVE", TARGET, 1062, CHART, False], + ] + assert tape[CUT-1] == ["MOVE", 7, 743, CHART, False] + assert tape[CUT] == ["ADD", TARGET, 7, "1", CHART] + touches = [i for i in range(KEY[0], CUT) if TARGET in + tape[i][1:3 if tape[i][0] in ("ADD", "COPY") else 2]] + assert touches == KEY + frames = [word["frames"][i] for i in (401, 1062, CHART)] + assert list(map(len, frames)) == [2, 5, 7] + assert span(frames[0]) < span(frames[1]) < span(frames[2]) + charts = [*word["initial"], *([None] * owned)] + zero = (F(0),) * len(probes) + values = [tuple(probe.get(i, F(0)) for probe in probes) for i in range(public+owned)] + for clock, (op, dest, *args) in enumerate(tape[:CUT]): + if clock == KEY[1]: + assert charts[SOURCE] == charts[TARGET] == 1062 + at_source = values[SOURCE] + if op == "MOVE": + before, after, is_owned = args + assert charts[dest] == before and is_owned == (dest >= public) + charts[dest] = after + elif op == "INIT": + chart, = args + assert dest >= public and charts[dest] is None and values[dest] == zero + charts[dest] = chart + elif op == "CLEAR": + chart, = args + assert dest >= public and charts[dest] == chart + charts[dest], values[dest] = None, zero + elif op == "SCALE": + coefficient, chart = args + assert charts[dest] == chart + values[dest] = tuple(scalar(coefficient)*x for x in values[dest]) + else: + src, coefficient, chart = args + assert op in ("ADD", "COPY") and dest != src and charts[dest] == charts[src] == chart + assert op != "COPY" or values[dest] == zero + values[dest] = tuple(x+scalar(coefficient)*y for x,y in zip(values[dest], values[src], strict=True)) + bank = [i for i, c in enumerate(charts) if c == CHART and i != TARGET] + assert charts[TARGET] == CHART and len(bank) == 5 and 7 in bank + return bank, at_source, [values[i] for i in bank] + + +def check(word, certificate): + assert certificate["key"] == KEY and certificate["cut"] == CUT + assert certificate["kind"] == "separator" + probe = input_map(certificate["input"], word["public"]) + mutant = {i:v for i,v in probe.items() if i != 1} + assert len(mutant) + 1 == len(probe) + bank, source, values = tape_check(word, [probe, mutant]) + assert source[0] == F(certificate["source_value"]) != 0 + assert all(row[0] == 0 for row in values) + assert source[1] == 0 or any(row[1] for row in values) + return {"chart_bank": bank, "kind": "separator", "source_value": str(source[0]), + "donor_values": {str(i):str(row[0]) for i,row in zip(bank,values,strict=True)}, + "mutant_drop_coordinate": 1, "mutant_source_value": str(source[1]), + "mutant_donor_values": {str(i):str(row[1]) for i,row in zip(bank,values,strict=True)}} + + +def stop(*_): + raise TimeoutError("20-second single-cut independent replay cap") + + +def main(word_path, certificate_path): + assert __debug__ and implementation.name == "cpython" and version_info[:2] == (3,12) + signal(SIGALRM, stop) + alarm(CAP) + blob = word_path.read_bytes() + assert sha256(blob).hexdigest() == COMPRESSED + raw = decompress(blob) + assert sha256(raw).hexdigest() == PAYLOAD + word = loads(raw, object_pairs_hook=unique) + certificate_raw = certificate_path.read_bytes() + result = check(word, loads(certificate_raw, object_pairs_hook=unique)) + alarm(0) + print(dumps({"head":HEAD, "caller":CALLER, "key":KEY, "cut":CUT, "chart":CHART, + "compressed_sha256":COMPRESSED, "uncompressed_sha256":PAYLOAD, + "certificate_sha256":sha256(certificate_raw).hexdigest(), "case_cap":1, + "runner_cap_seconds":CAP, **result}, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + assert len(argv) == 3, "pass the exact compressed native word and one certificate" + main(Path(argv[1]), Path(argv[2])) diff --git a/research/p104-chart922-delayed-bank-separator/inputs/7334-WORD.json.gz b/research/p104-chart922-delayed-bank-separator/inputs/7334-WORD.json.gz new file mode 100644 index 0000000000..73f4300719 Binary files /dev/null and b/research/p104-chart922-delayed-bank-separator/inputs/7334-WORD.json.gz differ diff --git a/research/p104-chart922-delayed-bank-separator/receipts/CERTIFICATE.json b/research/p104-chart922-delayed-bank-separator/receipts/CERTIFICATE.json new file mode 100644 index 0000000000..3d7d81fa7b --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/receipts/CERTIFICATE.json @@ -0,0 +1,7 @@ +{ + "key": [41944, 41946, 43419], + "cut": 43421, + "kind": "separator", + "input": {"1": "1", "2": "1", "311": "1"}, + "source_value": "1" +} diff --git a/research/p104-chart922-delayed-bank-separator/receipts/INDEPENDENT.json b/research/p104-chart922-delayed-bank-separator/receipts/INDEPENDENT.json new file mode 100644 index 0000000000..7cb67000ea --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/receipts/INDEPENDENT.json @@ -0,0 +1,41 @@ +{ + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "case_cap": 1, + "certificate_sha256": "d028783dbfe11928b5ed017752617f717ef31bea49fc969dc7b428ca450f70eb", + "chart": 922, + "chart_bank": [ + 7, + 587, + 779, + 949, + 960 + ], + "compressed_sha256": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "cut": 43421, + "donor_values": { + "587": "0", + "7": "0", + "779": "0", + "949": "0", + "960": "0" + }, + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "key": [ + 41944, + 41946, + 43419 + ], + "kind": "separator", + "mutant_donor_values": { + "587": "0", + "7": "0", + "779": "-2", + "949": "0", + "960": "0" + }, + "mutant_drop_coordinate": 1, + "mutant_source_value": "0", + "runner_cap_seconds": 20, + "source_value": "1", + "uncompressed_sha256": "9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" +} diff --git a/research/p104-chart922-delayed-bank-separator/receipts/LEAD.json b/research/p104-chart922-delayed-bank-separator/receipts/LEAD.json new file mode 100644 index 0000000000..3cc55ad0a5 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/receipts/LEAD.json @@ -0,0 +1,368 @@ +{ + "bank": { + "7": { + "2": "1/2", + "7": "1", + "9": "1/2", + "10": "1/2", + "11": "1/2", + "12": "1/2", + "17": "1/4", + "18": "1/2", + "19": "1/4", + "22": "1/2", + "23": "1/2", + "24": "1/2", + "25": "1/2", + "27": "1/2", + "31": "1/2", + "32": "1/2", + "33": "1/2", + "34": "1/2", + "35": "1/2", + "38": "1/4", + "39": "1/2", + "40": "1/4", + "45": "1/2", + "48": "1/2", + "49": "1/2", + "50": "1/2", + "54": "1/2", + "55": "1/2", + "56": "1/2", + "57": "1/2", + "62": "1/2", + "63": "1/2", + "70": "1/2", + "71": "1/2", + "72": "1/2", + "77": "1/2", + "79": "1/2", + "81": "1", + "85": "1/2", + "87": "1/2", + "89": "1/2", + "90": "1/2", + "91": "1/2", + "92": "1/2", + "94": "1/2", + "98": "1/2", + "100": "1/2", + "101": "1/2", + "102": "1/2", + "103": "1/2", + "107": "1/2", + "108": "1/2", + "109": "1/2", + "129": "-1/4", + "131": "-1/4", + "150": "-1/4", + "152": "-1/4", + "230": "-1/2", + "232": "1", + "238": "2", + "241": "1/2", + "245": "-1/4", + "251": "1/2", + "265": "1", + "278": "-2", + "311": "-1/2", + "320": "-1/8", + "331": "1/2", + "335": "3/4", + "344": "-4", + "352": "-1/4", + "364": "1", + "366": "-1/4", + "377": "1", + "399": "3/4", + "423": "1/8", + "448": "-3/2", + "471": "-3", + "473": "-1/2", + "487": "2", + "489": "2", + "547": "2", + "554": "-2", + "592": "1", + "599": "1", + "659": "-1/2", + "679": "1/2", + "756": "4", + "761": "-2", + "791": "1/2", + "810": "1", + "896": "1", + "952": "-4", + "1000": "2", + "1012": "1", + "1018": "-1", + "1033": "-7/2", + "1062": "-1", + "1063": "1/4", + "1065": "1/4", + "1074": "1", + "1090": "1/2", + "1203": "-1", + "1210": "1", + "1238": "3/4", + "1240": "-1/4", + "1243": "-2", + "1245": "-1/4", + "1255": "1", + "1258": "1", + "1259": "1", + "1279": "1", + "1311": "2", + "1321": "-1/4", + "1322": "3/4", + "1343": "-4" + }, + "587": { + "20": "1/2", + "34": "-1/2", + "37": "1/2", + "47": "-1/4", + "111": "-1/2", + "159": "1/4", + "265": "1", + "270": "1", + "284": "-2", + "303": "1", + "372": "1/16", + "408": "-1", + "418": "-1/2", + "423": "1/8", + "434": "-1", + "440": "1/2", + "442": "-1/4", + "444": "1", + "445": "-1/4", + "456": "-1/4", + "497": "1/4", + "499": "-1", + "537": "2", + "541": "-1", + "542": "1", + "587": "1", + "641": "-1", + "643": "-1", + "655": "1/8", + "679": "1/2", + "688": "1/4", + "711": "1/2", + "733": "1/4", + "757": "1/4", + "761": "-1/2", + "896": "-1/2", + "901": "-1/2", + "924": "1", + "969": "1/2", + "997": "-1", + "999": "1", + "1006": "-3/4", + "1008": "1/2", + "1013": "3/2", + "1017": "1", + "1018": "-1", + "1058": "-4", + "1063": "-1/4", + "1074": "-1/2", + "1090": "1/4", + "1102": "1/2", + "1127": "-1", + "1194": "-2", + "1196": "-1", + "1197": "1/2", + "1207": "-1/2", + "1214": "-1/2", + "1221": "-1/2", + "1224": "-1/2", + "1238": "1/4", + "1243": "1", + "1248": "1/4", + "1253": "1/2", + "1255": "-1/2", + "1258": "-1/2", + "1259": "-1/2", + "1274": "-1/2", + "1284": "-1", + "1322": "1/4", + "1340": "1" + }, + "779": { + "1": "2", + "2": "-5/2", + "6": "2", + "7": "-5", + "9": "-5/2", + "10": "-5/2", + "11": "-5/2", + "12": "-5/2", + "17": "-5/4", + "18": "-5/2", + "19": "-5/4", + "22": "-5/2", + "23": "-5/2", + "24": "-5/2", + "25": "-5/2", + "27": "-5/2", + "31": "-5/2", + "32": "-5/2", + "33": "-5/2", + "34": "-5/2", + "35": "-5/2", + "38": "-5/4", + "39": "-5/2", + "40": "-5/4", + "45": "-5/2", + "48": "-5/2", + "49": "-5/2", + "50": "-5/2", + "54": "-5/2", + "55": "-5/2", + "56": "-5/2", + "57": "-5/2", + "62": "-5/2", + "63": "-5/2", + "70": "-5/2", + "71": "-5/2", + "72": "-5/2", + "75": "2", + "77": "-5/2", + "79": "-5/2", + "81": "-5", + "82": "2", + "85": "-5/2", + "87": "-5/2", + "89": "-5/2", + "90": "-5/2", + "91": "-5/2", + "92": "-5/2", + "94": "-5/2", + "98": "-5/2", + "100": "-5/2", + "101": "-5/2", + "102": "-5/2", + "103": "-5/2", + "107": "-5/2", + "108": "-5/2", + "109": "-5/2", + "129": "5/4", + "131": "5/4", + "150": "5/4", + "152": "5/4", + "230": "5/2", + "232": "-5", + "238": "-10", + "241": "-5/2", + "245": "5/4", + "251": "-5/2", + "265": "-5", + "278": "10", + "311": "1/2", + "320": "5/8", + "331": "-5/2", + "335": "-15/4", + "344": "20", + "350": "-16", + "352": "5/4", + "364": "-5", + "366": "5/4", + "367": "1", + "377": "-5", + "399": "-15/4", + "415": "-4", + "423": "-5/8", + "448": "15/2", + "453": "-1", + "471": "15", + "473": "5/2", + "487": "-10", + "489": "-10", + "547": "-10", + "554": "10", + "592": "-5", + "659": "5/2", + "679": "-5/2", + "756": "-20", + "761": "10", + "791": "-5/2", + "810": "-5", + "896": "-5", + "952": "20", + "988": "3/4", + "991": "-1/4", + "1000": "-10", + "1012": "-5", + "1018": "5", + "1033": "35/2", + "1062": "5", + "1063": "-5/4", + "1065": "-5/4", + "1074": "-5", + "1090": "-5/2", + "1203": "5", + "1210": "-5", + "1238": "-15/4", + "1240": "5/4", + "1243": "10", + "1245": "5/4", + "1255": "-5", + "1258": "-5", + "1259": "-5", + "1279": "-5", + "1311": "-10", + "1321": "5/4", + "1322": "-15/4", + "1343": "20" + }, + "949": { + "949": "1" + }, + "960": { + "960": "1" + } + }, + "bank_roles": [ + 7, + 587, + 779, + 949, + 960 + ], + "case_cap": 1, + "clocks": [ + 41944, + 41946, + 43419 + ], + "coefficients": null, + "cut": 43421, + "gross": [ + "207666506667590248624841850467660284596999457489/1000000000000000000000000000000000000000000000000", + "2076665066675902486248418504676624377409172636959/10000000000000000000000000000000000000000000000000" + ], + "rank": 5, + "ranks": [ + 3, + 2, + 5 + ], + "seconds_cap": 30, + "separator": { + "input": { + "1": "1", + "2": "1", + "311": "1" + }, + "source_value": "1" + }, + "singletons": 2, + "target": { + "1": "1", + "6": "1", + "75": "1", + "82": "1" + } +} diff --git a/research/p104-chart922-delayed-bank-separator/replay.py b/research/p104-chart922-delayed-bank-separator/replay.py new file mode 100644 index 0000000000..f2d0f5c086 --- /dev/null +++ b/research/p104-chart922-delayed-bank-separator/replay.py @@ -0,0 +1,70 @@ +"""Replay the fixed chart-922 separating input and directed MOVE quote.""" +from fractions import Fraction as F +from hashlib import sha256 +from json import loads +from pathlib import Path, PurePosixPath +from runpy import run_path +from subprocess import run +from sys import executable, implementation, version_info + +ROOT = Path(__file__).resolve().parent +BANK = [7, 587, 779, 949, 960] + + +def unique(pairs): + values = dict(pairs) + assert len(values) == len(pairs), "duplicate JSON key" + return values + + +def read(name): + return loads((ROOT / name).read_bytes(), object_pairs_hook=unique) + + +def dot(row, probe): + return sum(F(value)*F(probe.get(key, 0)) for key, value in row.items()) + + +def main(): + assert __debug__ and implementation.name == "cpython" and version_info[:2] == (3, 12) + manifest = read("PINS.json") + files = {f.relative_to(ROOT).as_posix() for folder in ("engines", "inputs", "receipts") + for f in (ROOT / folder).iterdir() if f.is_file()} + assert set(manifest) == files | {"PROVENANCE.json"} + for name, digest in manifest.items(): + path = PurePosixPath(name) + assert not path.is_absolute() and ".." not in path.parts + assert sha256((ROOT / path).read_bytes()).hexdigest() == digest, name + + output = run([executable, "-I", "-B", str(ROOT / "engines/scalar.py"), + str(ROOT / "inputs/7334-WORD.json.gz"), + str(ROOT / "receipts/CERTIFICATE.json")], check=True, + capture_output=True, timeout=22).stdout + actual = loads(output, object_pairs_hook=unique) + assert actual == read("receipts/INDEPENDENT.json") + lead = read("receipts/LEAD.json") + certificate = read("receipts/CERTIFICATE.json") + assert lead["clocks"] == actual["key"] == [41944, 41946, 43419] + assert lead["cut"] == actual["cut"] == 43421 + assert lead["bank_roles"] == actual["chart_bank"] == BANK + assert lead["ranks"] == [3, 2, 5] and lead["rank"] == 5 + probe = certificate["input"] + assert lead["separator"]["input"] == probe == {"1": "1", "2": "1", "311": "1"} + assert dot(lead["target"], probe) == F(actual["source_value"]) == 1 + assert all(dot(lead["bank"][str(i)], probe) == F(actual["donor_values"][str(i)]) == 0 for i in BANK) + assert actual["mutant_drop_coordinate"] == 1 + mutant = {k:v for k,v in probe.items() if k != "1"} + assert dot(lead["target"], mutant) == F(actual["mutant_source_value"]) == 0 + assert [dot(lead["bank"][str(i)], mutant) for i in BANK] == [F(actual["mutant_donor_values"][str(i)]) for i in BANK] == [0, 0, -2, 0, 0] + + h = run_path(str(ROOT / "engines/pricing.py"))["power_bounds"] + lo, hi = map(F, ("0.00364665195644044790699554028334161", "0.00364665195644044790699554028334162")) + lower = 17 * (h(3, hi)[0] + h(2, hi)[0] - h(5, lo)[1]) + upper = 17 * (h(3, lo)[1] + h(2, lo)[1] - h(5, hi)[0]) + assert [lower, upper] == list(map(F, lead["gross"])) + assert F("0.20766650") < lower < upper < F("0.20766651") < 1 + print("PASS_CHART922_DELAYED_BANK: 5 donors zero, old source 1, one-component mutant rejected") + + +if __name__ == "__main__": + main()