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-chart127-delayed-bank-separators/NOTICE.md b/research/p104-chart127-delayed-bank-separators/NOTICE.md new file mode 100644 index 0000000000..dfdbd6ac80 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/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-chart127-delayed-bank-separators/PINS.json b/research/p104-chart127-delayed-bank-separators/PINS.json new file mode 100644 index 0000000000..818428ffd5 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/PINS.json @@ -0,0 +1,12 @@ +{ + "PROVENANCE.json": "589cb5414d37f7a4b853688d3357c0c784e5ef0ddbc09a28eb068a8d919930e5", + "engines/pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "engines/scalar.py": "e5f8df1653f1684f6b09318a80cb2811714e3c474a1be182447e5b06ecc2e69c", + "inputs/7334-WORD.json.gz": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "receipts/R220-CERTIFICATE.json": "4cd38f1504de10cd92c5357cb76e87d14f0c600c25014491900bac2fb3452572", + "receipts/R220-INDEPENDENT.json": "8fbc267dfcfc1ddd965464f278a0d221a36ffbbbfbaa6ddb6173a72e4f50669a", + "receipts/R220-LEAD-COMPARISON.json": "f54f997034eee712cdad5fcfe04e72a4ca5f5a8a849b7d1ebdeccd73316a98f3", + "receipts/R221-CERTIFICATE.json": "7ea643628abe18367882f038273fdf44b2817c685282fe41177a5868d4be9dfd", + "receipts/R221-INDEPENDENT.json": "3720aea14f575cf8a0719fd7fa5228d9684da3b56b890879bb817408f3807e23", + "receipts/R221-LEAD-COMPARISON.json": "3173acedb588a709b5cb3f26d6dd2780dfb05ccbb46f8a5875d8d5efeea0c984" +} diff --git a/research/p104-chart127-delayed-bank-separators/PROOF.md b/research/p104-chart127-delayed-bank-separators/PROOF.md new file mode 100644 index 0000000000..5a423306cd --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/PROOF.md @@ -0,0 +1,7 @@ +# Fixed late banks at chart 127 + +All clocks are zero-based in the exact #7334 word. For the first key target 1187 moves 668→650, adds −1 times the old source role 975 and moves 650→127. The next operand contact is ADD 46224, after entrant 43 moves into chart 127 at 46223. For the second key target 1043 moves 981→181, adds 2 times the old source role 935 and moves 181→127. The next operand contact is ADD 46568, after entrant 1031 moves into chart 127 at 46567. + +A tested rewrite would omit the old ADD and use a rational combination of the other live chart-127 fields to restore its value before the observer. It would keep the other paid work fixed. The literal replay enumerates the complete set of those fields, 298 and 417 respectively. For the first key the exact input has coordinates `x16=-4, x43=4, x44=-3, x416=3, x420=-6, x426=2, x427=6, x954=1`, with every other public coordinate zero. The second exact input is in `receipts/R221-CERTIFICATE.json`. Every bank functional vanishes on its corresponding input while the source functional equals 1. Thus no rational combination equals either omitted source functional. The nonzero coefficient on the old ADD preserves the obstruction. + +The nested frame dimensions are 3, 7, 9 and 7, 8, 9. Even granting the direct quotients, the relaxed price gains are `17*(H(4)+H(2)-H(6))` and `17*(2*H(1)-H(2))`, with `H(r)=r^(1−κ)`. The directed upper bounds are below 0.235561 and 0.085833 raw. Their joint relaxed upper bound is below 0.3214 raw. These are isolated relaxed quotes with unchanged surrounding invoices. Either one is defeated by an added paid rank-one position. The exact span failures already exclude both frozen rewrites. diff --git a/research/p104-chart127-delayed-bank-separators/PROVENANCE.json b/research/p104-chart127-delayed-bank-separators/PROVENANCE.json new file mode 100644 index 0000000000..814e6b5498 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/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-chart127-delayed-bank-separators/README.md b/research/p104-chart127-delayed-bank-separators/README.md new file mode 100644 index 0000000000..c278edf513 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/README.md @@ -0,0 +1,22 @@ +# Exclude the remaining delayed chart-127 corrections + +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, two distinct fixed late banks left open by [#7438](https://github.com/CrocSwap/integer-mult-bounds/pull/7438) cannot recover their omitted old source. + +| Old key | Latest cut | Available chart-127 donors | Source value | Nonzero input coordinates | +|---|---:|---:|---:|---:| +| `[40430,40432,46222]` | 46224 | 298 | 1 | 8 | +| `[43091,43093,46566]` | 46568 | 417 | 1 | 157 | + +Every donor evaluates to zero on its corresponding exact probe. 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-chart127-delayed-bank-separators/replay.py +``` + +The [proof](PROOF.md) and [verification](VERIFICATION.md) describe the exact local exclusions and price. [#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, [#7362](https://github.com/CrocSwap/integer-mult-bounds/pull/7362) the directed rank arithmetic and [#7444](https://github.com/CrocSwap/integer-mult-bounds/pull/7444) the prior scalar replay structure for a different chart. + +## Open next questions + +No additional chart-127 key from the changed #7438 latest-cut inventory was left in this package's scope. A changed source, later observer, alternative donor frame or altered paid itinerary is a new experiment. Any future case needs fresh literal clocks and a positive fully charged price before a build. diff --git a/research/p104-chart127-delayed-bank-separators/SOURCES.json b/research/p104-chart127-delayed-bank-separators/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/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-chart127-delayed-bank-separators/TASK.json b/research/p104-chart127-delayed-bank-separators/TASK.json new file mode 100644 index 0000000000..4b1102b8d9 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113 and two distinct changed chart-127 cuts from #7438. Keys [40430,40432,46222] and [43091,43093,46566], pre-observer cuts 46224 and 46568. Fixed old sources and surrounding paid work.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 chart-127 delayed bank audits", + "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": "Separate exact public input probes give source 1 and zero on every donor in the two complete 298- and 417-role chart-127 banks.", + "open_questions": [ + { + "blocked_by": "The exact fixed charts and cut identities in this package exclude both original rewrites.", + "first_step": "Freeze a distinct new scope and price the complete caller before any construction.", + "question": "Can a different paid itinerary or donor frame avoid these exact span failures?", + "why_it_matters": "Only a positive and fully replayed alternative would move the signed paid recurrence." + } + ], + "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": "Two frozen keys, one sparse exact separating input and one component-removal control for each, independently capped at 20 runner seconds per key. No other keys tested.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-chart127-delayed-bank-separators/VERIFICATION.md b/research/p104-chart127-delayed-bank-separators/VERIFICATION.md new file mode 100644 index 0000000000..423c6a8419 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/VERIFICATION.md @@ -0,0 +1,5 @@ +The two bounded exact row solves completed in 4.77 and 5.00 seconds, each under its 30-second cap. The independent literal scalar runs completed in 0.20 and 0.24 seconds under separate 20-second caps. They authenticated both compressed and uncompressed hashes, verified literal clocks and ownership along the prefix, checked strict frame nesting, and enumerated each full chart bank. No other key was tested. + +Each lead rational row was evaluated on the separating and deliberately corrupted probes. All 715 donor comparisons and both sources agreed with the independent literal evaluator for each probe type. The compact receipts pin the original full row results by SHA-256. The public replay verifies the scalar certificate directly from the word and compares all exact values with the frozen receipts. + +Removing x16 from the first probe leaves its source at 1 but makes 90 donors nonzero. Removing x1 from the second leaves its source at 1 but makes 65 donors nonzero. Both changed probes therefore fail the separation test. The wrapper regenerates both directed price intervals from the pinned crossing interval and checks their joint upper bound. diff --git a/research/p104-chart127-delayed-bank-separators/VERIFY.json b/research/p104-chart127-delayed-bank-separators/VERIFY.json new file mode 100644 index 0000000000..cf2c91de86 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Authenticate the word, replay both exact chart-127 separating inputs and mutants, and check their directed rank quotes.", + "timeout_seconds": 50 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-chart127-delayed-bank-separators/engines/pricing.py b/research/p104-chart127-delayed-bank-separators/engines/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/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-chart127-delayed-bank-separators/engines/scalar.py b/research/p104-chart127-delayed-bank-separators/engines/scalar.py new file mode 100644 index 0000000000..e536638d59 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/engines/scalar.py @@ -0,0 +1,146 @@ +"""Literal independent scalar replay of the two frozen chart-127 banks.""" +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" +CAP, CHART = 20, 127 +CASES = { + (40430, 40432, 46222): { + "cut": 46224, "target": 1187, "source": 975, "source_coefficient": "-1", + "first": 668, "middle": 650, "frame_ranks": [3, 7, 9], + "entrant": 43, "entrant_first": 498, "observer_coefficient": "1/2", + "bank_count": 298, "mutant_drop": 16, + }, + (43091, 43093, 46566): { + "cut": 46568, "target": 1043, "source": 935, "source_coefficient": "2", + "first": 981, "middle": 181, "frame_ranks": [7, 8, 9], + "entrant": 1031, "entrant_first": 129, "observer_coefficient": "-2", + "bank_count": 417, "mutant_drop": 1, + }, +} + + +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 tape_check(word, certificate): + key = certificate["key"] + case = CASES[tuple(key)] + cut = case["cut"] + target, source = case["target"], case["source"] + first, middle = case["first"], case["middle"] + entrant = case["entrant"] + drop = case["mutant_drop"] + assert certificate["cut"] == cut and certificate["kind"] == "separator" + 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, first, middle, False], + ["ADD", target, source, case["source_coefficient"], middle], + ["MOVE", target, middle, CHART, False], + ] + assert tape[cut-1] == ["MOVE", entrant, case["entrant_first"], CHART, False] + assert tape[cut] == ["ADD", target, entrant, case["observer_coefficient"], 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 (first, middle, CHART)] + assert list(map(len, frames)) == case["frame_ranks"] + assert span(frames[0]) < span(frames[1]) < span(frames[2]) + + raw_probe = certificate["input"] + assert all(str(int(i)) == i and 0 <= int(i) < public for i in raw_probe) + probe = {int(i): F(v) for i,v in raw_probe.items()} + assert drop in probe and all(probe.values()) + zero = (F(0), F(0)) + charts = [*word["initial"], *([None] * owned)] + values = [zero for _ in charts] + for i, value in probe.items(): + values[i] = (value, F(0) if i == drop else value) + for clock, (op, dest, *args) in enumerate(tape[:cut]): + if clock == key[1]: + assert charts[source] == charts[target] == middle + 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, chart in enumerate(charts) if chart == CHART and i != target] + assert charts[target] == CHART and entrant in bank and len(bank) == case["bank_count"] + assert at_source[0] == F(certificate["source_value"]) != 0 + assert all(values[i][0] == 0 for i in bank) + assert at_source[1] == 0 or any(values[i][1] for i in bank) + return {"key":key, "cut":cut, "chart":CHART, "chart_bank":bank, "kind":"separator", + "source_value":str(at_source[0]), + "donor_values":{str(i):str(values[i][0]) for i in bank}, + "mutant_drop_coordinate":drop, "mutant_source_value":str(at_source[1]), + "mutant_donor_values":{str(i):str(values[i][1]) for i in bank}} + + +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 + payload = decompress(blob) + assert sha256(payload).hexdigest() == PAYLOAD + word = loads(payload, object_pairs_hook=unique) + certificate_raw = certificate_path.read_bytes() + result = tape_check(word, loads(certificate_raw, object_pairs_hook=unique)) + alarm(0) + print(dumps({"head":HEAD, "caller":CALLER, "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 + main(Path(argv[1]), Path(argv[2])) diff --git a/research/p104-chart127-delayed-bank-separators/inputs/7334-WORD.json.gz b/research/p104-chart127-delayed-bank-separators/inputs/7334-WORD.json.gz new file mode 100644 index 0000000000..73f4300719 Binary files /dev/null and b/research/p104-chart127-delayed-bank-separators/inputs/7334-WORD.json.gz differ diff --git a/research/p104-chart127-delayed-bank-separators/receipts/R220-CERTIFICATE.json b/research/p104-chart127-delayed-bank-separators/receipts/R220-CERTIFICATE.json new file mode 100644 index 0000000000..49cf3a4ec7 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/receipts/R220-CERTIFICATE.json @@ -0,0 +1,7 @@ +{ + "key": [40430, 40432, 46222], + "cut": 46224, + "kind": "separator", + "input": {"16": "-4", "43": "4", "44": "-3", "416": "3", "420": "-6", "426": "2", "427": "6", "954": "1"}, + "source_value": "1" +} diff --git a/research/p104-chart127-delayed-bank-separators/receipts/R220-INDEPENDENT.json b/research/p104-chart127-delayed-bank-separators/receipts/R220-INDEPENDENT.json new file mode 100644 index 0000000000..2955526e19 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/receipts/R220-INDEPENDENT.json @@ -0,0 +1,920 @@ +{ + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "case_cap": 1, + "certificate_sha256": "4cd38f1504de10cd92c5357cb76e87d14f0c600c25014491900bac2fb3452572", + "chart": 127, + "chart_bank": [ + 1, + 3, + 5, + 9, + 10, + 16, + 17, + 18, + 19, + 20, + 21, + 24, + 28, + 34, + 37, + 43, + 54, + 59, + 60, + 66, + 67, + 69, + 78, + 87, + 92, + 94, + 97, + 102, + 103, + 110, + 126, + 173, + 205, + 226, + 228, + 230, + 234, + 236, + 240, + 249, + 252, + 254, + 255, + 256, + 263, + 264, + 272, + 280, + 284, + 286, + 288, + 297, + 299, + 300, + 312, + 315, + 319, + 320, + 334, + 338, + 343, + 344, + 347, + 352, + 363, + 364, + 376, + 392, + 393, + 395, + 399, + 402, + 409, + 415, + 417, + 421, + 425, + 431, + 436, + 440, + 444, + 446, + 447, + 448, + 449, + 464, + 466, + 468, + 469, + 470, + 471, + 472, + 473, + 475, + 477, + 482, + 484, + 485, + 489, + 494, + 496, + 502, + 504, + 505, + 517, + 519, + 525, + 532, + 554, + 561, + 566, + 567, + 570, + 572, + 573, + 586, + 587, + 589, + 590, + 594, + 617, + 619, + 620, + 635, + 643, + 653, + 655, + 662, + 666, + 667, + 669, + 674, + 679, + 695, + 698, + 702, + 707, + 735, + 737, + 739, + 743, + 744, + 745, + 758, + 764, + 772, + 773, + 774, + 775, + 777, + 779, + 781, + 787, + 789, + 797, + 800, + 806, + 813, + 819, + 820, + 821, + 822, + 823, + 824, + 826, + 836, + 839, + 840, + 845, + 848, + 852, + 857, + 862, + 865, + 872, + 873, + 988, + 990, + 991, + 992, + 994, + 995, + 996, + 1000, + 1004, + 1008, + 1010, + 1013, + 1015, + 1016, + 1018, + 1019, + 1020, + 1022, + 1027, + 1030, + 1041, + 1053, + 1057, + 1060, + 1062, + 1070, + 1077, + 1081, + 1091, + 1093, + 1095, + 1098, + 1100, + 1105, + 1106, + 1109, + 1110, + 1112, + 1113, + 1125, + 1126, + 1127, + 1128, + 1132, + 1136, + 1137, + 1148, + 1155, + 1157, + 1161, + 1162, + 1168, + 1170, + 1172, + 1173, + 1175, + 1182, + 1184, + 1188, + 1193, + 1197, + 1203, + 1204, + 1205, + 1206, + 1207, + 1208, + 1240, + 1263, + 1264, + 1304, + 1309, + 1327, + 1328, + 1353, + 1354, + 1359, + 1367, + 1374, + 1379, + 1387, + 1404, + 1409, + 1410, + 1424, + 1430, + 1435, + 1436, + 1443, + 1444, + 1445, + 1453, + 1457, + 1458, + 1459, + 1460, + 1461, + 1463, + 1464, + 1465, + 1466, + 1467, + 1469, + 1470, + 1471, + 1472, + 1473, + 1474, + 1475, + 1476, + 1477, + 1478, + 1479, + 1484, + 1485, + 1486, + 1487, + 1489, + 1490, + 1493, + 1495, + 1499 + ], + "compressed_sha256": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "cut": 46224, + "donor_values": { + "1": "0", + "10": "0", + "1000": "0", + "1004": "0", + "1008": "0", + "1010": "0", + "1013": "0", + "1015": "0", + "1016": "0", + "1018": "0", + "1019": "0", + "102": "0", + "1020": "0", + "1022": "0", + "1027": "0", + "103": "0", + "1030": "0", + "1041": "0", + "1053": "0", + "1057": "0", + "1060": "0", + "1062": "0", + "1070": "0", + "1077": "0", + "1081": "0", + "1091": "0", + "1093": "0", + "1095": "0", + "1098": "0", + "110": "0", + "1100": "0", + "1105": "0", + "1106": "0", + "1109": "0", + "1110": "0", + "1112": "0", + "1113": "0", + "1125": "0", + "1126": "0", + "1127": "0", + "1128": "0", + "1132": "0", + "1136": "0", + "1137": "0", + "1148": "0", + "1155": "0", + "1157": "0", + "1161": "0", + "1162": "0", + "1168": "0", + "1170": "0", + "1172": "0", + "1173": "0", + "1175": "0", + "1182": "0", + "1184": "0", + "1188": "0", + "1193": "0", + "1197": "0", + "1203": "0", + "1204": "0", + "1205": "0", + "1206": "0", + "1207": "0", + "1208": "0", + "1240": "0", + "126": "0", + "1263": "0", + "1264": "0", + "1304": "0", + "1309": "0", + "1327": "0", + "1328": "0", + "1353": "0", + "1354": "0", + "1359": "0", + "1367": "0", + "1374": "0", + "1379": "0", + "1387": "0", + "1404": "0", + "1409": "0", + "1410": "0", + "1424": "0", + "1430": "0", + "1435": "0", + "1436": "0", + "1443": "0", + "1444": "0", + "1445": "0", + "1453": "0", + "1457": "0", + "1458": "0", + "1459": "0", + "1460": "0", + "1461": "0", + "1463": "0", + "1464": "0", + "1465": "0", + "1466": "0", + "1467": "0", + "1469": "0", + "1470": "0", + "1471": "0", + "1472": "0", + "1473": "0", + "1474": "0", + "1475": "0", + "1476": "0", + "1477": "0", + "1478": "0", + "1479": "0", + "1484": "0", + "1485": "0", + "1486": "0", + "1487": "0", + "1489": "0", + "1490": "0", + "1493": "0", + "1495": "0", + "1499": "0", + "16": "0", + "17": "0", + "173": "0", + "18": "0", + "19": "0", + "20": "0", + "205": "0", + "21": "0", + "226": "0", + "228": "0", + "230": "0", + "234": "0", + "236": "0", + "24": "0", + "240": "0", + "249": "0", + "252": "0", + "254": "0", + "255": "0", + "256": "0", + "263": "0", + "264": "0", + "272": "0", + "28": "0", + "280": "0", + "284": "0", + "286": "0", + "288": "0", + "297": "0", + "299": "0", + "3": "0", + "300": "0", + "312": "0", + "315": "0", + "319": "0", + "320": "0", + "334": "0", + "338": "0", + "34": "0", + "343": "0", + "344": "0", + "347": "0", + "352": "0", + "363": "0", + "364": "0", + "37": "0", + "376": "0", + "392": "0", + "393": "0", + "395": "0", + "399": "0", + "402": "0", + "409": "0", + "415": "0", + "417": "0", + "421": "0", + "425": "0", + "43": "0", + "431": "0", + "436": "0", + "440": "0", + "444": "0", + "446": "0", + "447": "0", + "448": "0", + "449": "0", + "464": "0", + "466": "0", + "468": "0", + "469": "0", + "470": "0", + "471": "0", + "472": "0", + "473": "0", + "475": "0", + "477": "0", + "482": "0", + "484": "0", + "485": "0", + "489": "0", + "494": "0", + "496": "0", + "5": "0", + "502": "0", + "504": "0", + "505": "0", + "517": "0", + "519": "0", + "525": "0", + "532": "0", + "54": "0", + "554": "0", + "561": "0", + "566": "0", + "567": "0", + "570": "0", + "572": "0", + "573": "0", + "586": "0", + "587": "0", + "589": "0", + "59": "0", + "590": "0", + "594": "0", + "60": "0", + "617": "0", + "619": "0", + "620": "0", + "635": "0", + "643": "0", + "653": "0", + "655": "0", + "66": "0", + "662": "0", + "666": "0", + "667": "0", + "669": "0", + "67": "0", + "674": "0", + "679": "0", + "69": "0", + "695": "0", + "698": "0", + "702": "0", + "707": "0", + "735": "0", + "737": "0", + "739": "0", + "743": "0", + "744": "0", + "745": "0", + "758": "0", + "764": "0", + "772": "0", + "773": "0", + "774": "0", + "775": "0", + "777": "0", + "779": "0", + "78": "0", + "781": "0", + "787": "0", + "789": "0", + "797": "0", + "800": "0", + "806": "0", + "813": "0", + "819": "0", + "820": "0", + "821": "0", + "822": "0", + "823": "0", + "824": "0", + "826": "0", + "836": "0", + "839": "0", + "840": "0", + "845": "0", + "848": "0", + "852": "0", + "857": "0", + "862": "0", + "865": "0", + "87": "0", + "872": "0", + "873": "0", + "9": "0", + "92": "0", + "94": "0", + "97": "0", + "988": "0", + "990": "0", + "991": "0", + "992": "0", + "994": "0", + "995": "0", + "996": "0" + }, + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "key": [ + 40430, + 40432, + 46222 + ], + "kind": "separator", + "mutant_donor_values": { + "1": "0", + "10": "0", + "1000": "0", + "1004": "0", + "1008": "0", + "1010": "1/2", + "1013": "0", + "1015": "0", + "1016": "0", + "1018": "0", + "1019": "0", + "102": "0", + "1020": "0", + "1022": "-1/2", + "1027": "1/2", + "103": "0", + "1030": "0", + "1041": "0", + "1053": "-4", + "1057": "0", + "1060": "0", + "1062": "0", + "1070": "0", + "1077": "-3", + "1081": "0", + "1091": "0", + "1093": "1/2", + "1095": "0", + "1098": "1/2", + "110": "0", + "1100": "-16", + "1105": "0", + "1106": "0", + "1109": "-3", + "1110": "0", + "1112": "0", + "1113": "2", + "1125": "0", + "1126": "0", + "1127": "0", + "1128": "2", + "1132": "4", + "1136": "4", + "1137": "4", + "1148": "-4", + "1155": "0", + "1157": "0", + "1161": "0", + "1162": "0", + "1168": "0", + "1170": "0", + "1172": "0", + "1173": "0", + "1175": "0", + "1182": "-4", + "1184": "0", + "1188": "0", + "1193": "0", + "1197": "0", + "1203": "0", + "1204": "0", + "1205": "0", + "1206": "0", + "1207": "0", + "1208": "0", + "1240": "0", + "126": "0", + "1263": "0", + "1264": "0", + "1304": "0", + "1309": "-1/2", + "1327": "-1", + "1328": "0", + "1353": "0", + "1354": "0", + "1359": "0", + "1367": "-4", + "1374": "0", + "1379": "0", + "1387": "1/2", + "1404": "-2", + "1409": "0", + "1410": "-1", + "1424": "0", + "1430": "0", + "1435": "0", + "1436": "0", + "1443": "0", + "1444": "4", + "1445": "0", + "1453": "0", + "1457": "0", + "1458": "0", + "1459": "0", + "1460": "0", + "1461": "0", + "1463": "0", + "1464": "0", + "1465": "0", + "1466": "0", + "1467": "0", + "1469": "0", + "1470": "0", + "1471": "0", + "1472": "0", + "1473": "0", + "1474": "0", + "1475": "0", + "1476": "0", + "1477": "0", + "1478": "0", + "1479": "-4", + "1484": "8", + "1485": "0", + "1486": "0", + "1487": "0", + "1489": "0", + "1490": "0", + "1493": "0", + "1495": "0", + "1499": "0", + "16": "-8", + "17": "0", + "173": "4", + "18": "0", + "19": "-1", + "20": "4", + "205": "2", + "21": "0", + "226": "0", + "228": "4", + "230": "0", + "234": "0", + "236": "0", + "24": "-3", + "240": "4", + "249": "0", + "252": "0", + "254": "-2", + "255": "0", + "256": "-4", + "263": "-4", + "264": "0", + "272": "0", + "28": "0", + "280": "0", + "284": "-1", + "286": "-1", + "288": "0", + "297": "0", + "299": "0", + "3": "-2", + "300": "0", + "312": "4", + "315": "4", + "319": "0", + "320": "0", + "334": "1", + "338": "2", + "34": "0", + "343": "-2", + "344": "1", + "347": "2", + "352": "0", + "363": "0", + "364": "1", + "37": "0", + "376": "1", + "392": "1", + "393": "0", + "395": "0", + "399": "0", + "402": "0", + "409": "4", + "415": "0", + "417": "-4", + "421": "-8", + "425": "0", + "43": "0", + "431": "0", + "436": "0", + "440": "0", + "444": "0", + "446": "0", + "447": "0", + "448": "0", + "449": "0", + "464": "8", + "466": "-4", + "468": "-8", + "469": "0", + "470": "0", + "471": "-2", + "472": "0", + "473": "0", + "475": "0", + "477": "0", + "482": "-2", + "484": "0", + "485": "0", + "489": "0", + "494": "1", + "496": "0", + "5": "0", + "502": "1", + "504": "0", + "505": "0", + "517": "1", + "519": "1", + "525": "4", + "532": "0", + "54": "0", + "554": "-2", + "561": "-2", + "566": "0", + "567": "0", + "570": "0", + "572": "0", + "573": "0", + "586": "-4", + "587": "0", + "589": "0", + "59": "0", + "590": "0", + "594": "0", + "60": "0", + "617": "4", + "619": "1", + "620": "0", + "635": "1", + "643": "0", + "653": "-2", + "655": "0", + "66": "0", + "662": "-2", + "666": "0", + "667": "-3", + "669": "2", + "67": "-2", + "674": "0", + "679": "0", + "69": "0", + "695": "-2", + "698": "-2", + "702": "-1", + "707": "0", + "735": "4", + "737": "0", + "739": "0", + "743": "0", + "744": "-1", + "745": "0", + "758": "0", + "764": "2", + "772": "0", + "773": "0", + "774": "1/2", + "775": "0", + "777": "-4", + "779": "0", + "78": "0", + "781": "0", + "787": "0", + "789": "0", + "797": "0", + "800": "2", + "806": "1/2", + "813": "0", + "819": "0", + "820": "0", + "821": "0", + "822": "-4", + "823": "0", + "824": "0", + "826": "0", + "836": "0", + "839": "1", + "840": "0", + "845": "7", + "848": "0", + "852": "0", + "857": "0", + "862": "0", + "865": "1/4", + "87": "0", + "872": "0", + "873": "0", + "9": "4", + "92": "0", + "94": "0", + "97": "0", + "988": "0", + "990": "0", + "991": "0", + "992": "-7", + "994": "0", + "995": "0", + "996": "6" + }, + "mutant_drop_coordinate": 16, + "mutant_source_value": "1", + "runner_cap_seconds": 20, + "source_value": "1", + "uncompressed_sha256": "9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" +} diff --git a/research/p104-chart127-delayed-bank-separators/receipts/R220-LEAD-COMPARISON.json b/research/p104-chart127-delayed-bank-separators/receipts/R220-LEAD-COMPARISON.json new file mode 100644 index 0000000000..536beafbab --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/receipts/R220-LEAD-COMPARISON.json @@ -0,0 +1,25 @@ +{ + "bank_rank": 298, + "cut": 46224, + "gross": [ + "588900669425359607009258574507509571470000450793/2500000000000000000000000000000000000000000000000", + "471120535540287685607406859606013634563900076553/2000000000000000000000000000000000000000000000000" + ], + "key": [ + 40430, + 40432, + 46222 + ], + "lead_result_sha256": "5e562b477b652fd6a38478c94bd9bc988cb3b08f3be7df89c0d63ace5b5a03f1", + "rank_split": [ + 4, + 2, + 6 + ], + "roles": 298, + "source_values": [ + "1", + "1" + ], + "violating_mutant_donors": 90 +} diff --git a/research/p104-chart127-delayed-bank-separators/receipts/R221-CERTIFICATE.json b/research/p104-chart127-delayed-bank-separators/receipts/R221-CERTIFICATE.json new file mode 100644 index 0000000000..b4793be00e --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/receipts/R221-CERTIFICATE.json @@ -0,0 +1,169 @@ +{ + "cut": 46568, + "input": { + "1": "-791/258", + "10": "203/3096", + "101": "-13/43", + "104": "-5941/10320", + "105": "-1597/3096", + "106": "-337/3096", + "11": "-83/86", + "110": "-337/3096", + "111": "337/3096", + "12": "11/258", + "15": "326/387", + "16": "131323/30960", + "17": "-724/387", + "18": "26/43", + "19": "-931/387", + "20": "-163/387", + "22": "230/387", + "228": "2177/3096", + "229": "-1389419/23938272", + "23": "-230/387", + "233": "7285885/5984568", + "235": "7/36", + "241": "-395/3096", + "242": "-77/516", + "243": "1307/2064", + "244": "32/129", + "254": "2713/2580", + "258": "-3/172", + "26": "-395/387", + "271": "-745/6192", + "272": "67/129", + "276": "-67/129", + "278": "7294099/1496142", + "281": "-58/387", + "285": "-323/344", + "288": "59/72", + "29": "-8/387", + "290": "-203/774", + "30": "164/129", + "303": "-1/24", + "31": "-11/258", + "313": "71/387", + "332": "-326/387", + "336": "-1495/774", + "34": "230/387", + "342": "439/774", + "344": "-245/774", + "350": "-943/774", + "352": "-22/387", + "356": "4/129", + "36": "337/3096", + "365": "-899/6192", + "366": "-4097705/2992284", + "367": "-35/129", + "37": "-337/3096", + "370": "-395/387", + "372": "-238/387", + "38": "-724/387", + "380": "5363/12384", + "388": "443/1548", + "39": "1306963/5984568", + "396": "21029/6192", + "398": "1429/1548", + "40": "-11/9", + "404": "337/774", + "408": "71/1548", + "41": "-337/1032", + "413": "337/774", + "414": "-2809/3096", + "415": "2693/1548", + "416": "-4827/1376", + "417": "96233/20640", + "42": "-757/1032", + "420": "7607/1032", + "423": "652/387", + "424": "1103/3870", + "426": "-15527/6192", + "427": "-190871/30960", + "428": "-4655/3096", + "429": "337/1548", + "43": "-131323/30960", + "430": "25/24", + "438": "269/3096", + "44": "-9811/7740", + "444": "337/3096", + "445": "259/774", + "46": "163/387", + "461": "-326/387", + "467": "1765/344", + "47": "-47/86", + "474": "60330659/5984568", + "475": "67/258", + "476": "17/172", + "479": "-4127/1548", + "486": "197/3096", + "487": "4855645/997428", + "488": "5/258", + "489": "-11/774", + "49": "-230/387", + "492": "2029/1548", + "494": "-67/258", + "497": "119/774", + "498": "-163/258", + "499": "-191/1548", + "501": "-2633/3096", + "508": "211/3096", + "511": "-237/172", + "512": "-253/774", + "513": "10262705/5984568", + "517": "67/1032", + "521": "-35/258", + "524": "55/387", + "526": "-865/1548", + "527": "-7013/1548", + "53": "326/387", + "531": "-479/516", + "537": "443/1548", + "539": "-649/1548", + "541": "-41/1548", + "542": "-103/172", + "55": "13/43", + "558": "-703/1548", + "564": "703/1548", + "568": "-865/3096", + "569": "685/3096", + "573": "-2809/3096", + "576": "41/774", + "59": "-8/387", + "591": "-295/774", + "6": "-791/258", + "60": "-428/387", + "602": "203/1548", + "605": "-203/1548", + "608": "67/258", + "609": "67/258", + "610": "-67/258", + "613": "-67/258", + "618": "1609639/3989712", + "62": "281/258", + "620": "676499/1496142", + "621": "35555/498714", + "622": "227401/748071", + "63": "8/129", + "635": "211/3096", + "643": "167/3096", + "655": "8/387", + "665": "-163/3096", + "672": "-703/1548", + "680": "32/129", + "688": "134/129", + "70": "-265/258", + "77": "26/43", + "79": "-163/387", + "8": "395/387", + "86": "1495/774", + "935": "1", + "99": "-652/387" + }, + "key": [ + 43091, + 43093, + 46566 + ], + "kind": "separator", + "source_value": "1" +} diff --git a/research/p104-chart127-delayed-bank-separators/receipts/R221-INDEPENDENT.json b/research/p104-chart127-delayed-bank-separators/receipts/R221-INDEPENDENT.json new file mode 100644 index 0000000000..5ff1c3352e --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/receipts/R221-INDEPENDENT.json @@ -0,0 +1,1277 @@ +{ + "caller": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "case_cap": 1, + "certificate_sha256": "7ea643628abe18367882f038273fdf44b2817c685282fe41177a5868d4be9dfd", + "chart": 127, + "chart_bank": [ + 1, + 3, + 5, + 7, + 9, + 10, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 24, + 28, + 34, + 37, + 38, + 43, + 52, + 53, + 54, + 56, + 59, + 60, + 66, + 67, + 69, + 78, + 79, + 87, + 92, + 94, + 97, + 102, + 103, + 105, + 109, + 110, + 126, + 151, + 173, + 205, + 226, + 228, + 230, + 234, + 236, + 240, + 248, + 249, + 252, + 254, + 255, + 256, + 257, + 263, + 264, + 267, + 272, + 274, + 276, + 279, + 280, + 284, + 285, + 286, + 288, + 294, + 295, + 296, + 297, + 299, + 300, + 303, + 312, + 315, + 316, + 319, + 320, + 328, + 331, + 332, + 334, + 338, + 340, + 343, + 344, + 347, + 348, + 350, + 352, + 354, + 358, + 359, + 363, + 364, + 365, + 376, + 379, + 382, + 392, + 393, + 395, + 399, + 402, + 409, + 415, + 417, + 421, + 425, + 431, + 436, + 439, + 440, + 444, + 446, + 447, + 448, + 449, + 460, + 461, + 464, + 466, + 468, + 469, + 470, + 471, + 472, + 473, + 475, + 477, + 478, + 482, + 484, + 485, + 489, + 490, + 494, + 496, + 502, + 504, + 505, + 506, + 517, + 518, + 519, + 520, + 523, + 525, + 526, + 528, + 532, + 549, + 553, + 554, + 561, + 566, + 567, + 569, + 570, + 571, + 572, + 573, + 583, + 586, + 587, + 589, + 590, + 594, + 595, + 608, + 609, + 610, + 612, + 613, + 614, + 617, + 619, + 620, + 627, + 635, + 637, + 643, + 650, + 651, + 652, + 653, + 654, + 655, + 660, + 661, + 662, + 663, + 664, + 666, + 667, + 669, + 671, + 672, + 674, + 676, + 677, + 679, + 681, + 682, + 683, + 684, + 688, + 689, + 695, + 698, + 702, + 704, + 707, + 709, + 732, + 735, + 737, + 738, + 739, + 743, + 744, + 745, + 752, + 758, + 764, + 770, + 772, + 773, + 774, + 775, + 777, + 779, + 781, + 787, + 789, + 791, + 797, + 800, + 802, + 806, + 808, + 812, + 813, + 819, + 820, + 821, + 822, + 823, + 824, + 825, + 826, + 832, + 836, + 837, + 839, + 840, + 842, + 843, + 845, + 848, + 852, + 853, + 857, + 859, + 862, + 865, + 870, + 871, + 872, + 873, + 875, + 988, + 990, + 991, + 992, + 994, + 995, + 996, + 1000, + 1002, + 1004, + 1008, + 1010, + 1013, + 1015, + 1016, + 1018, + 1019, + 1020, + 1022, + 1027, + 1030, + 1031, + 1041, + 1053, + 1057, + 1060, + 1062, + 1070, + 1077, + 1078, + 1080, + 1081, + 1091, + 1093, + 1095, + 1098, + 1100, + 1105, + 1106, + 1109, + 1110, + 1112, + 1113, + 1125, + 1126, + 1127, + 1128, + 1129, + 1132, + 1136, + 1137, + 1148, + 1153, + 1155, + 1157, + 1161, + 1162, + 1164, + 1168, + 1170, + 1172, + 1173, + 1175, + 1178, + 1182, + 1183, + 1184, + 1187, + 1188, + 1193, + 1196, + 1197, + 1200, + 1203, + 1204, + 1205, + 1206, + 1207, + 1208, + 1240, + 1263, + 1264, + 1304, + 1307, + 1309, + 1319, + 1327, + 1328, + 1353, + 1354, + 1359, + 1367, + 1374, + 1378, + 1379, + 1382, + 1385, + 1387, + 1404, + 1405, + 1409, + 1410, + 1424, + 1430, + 1434, + 1435, + 1436, + 1441, + 1443, + 1444, + 1445, + 1449, + 1453, + 1457, + 1458, + 1459, + 1460, + 1461, + 1463, + 1464, + 1465, + 1466, + 1467, + 1469, + 1470, + 1471, + 1472, + 1473, + 1474, + 1475, + 1476, + 1477, + 1478, + 1479, + 1484, + 1485, + 1486, + 1487, + 1489, + 1490, + 1493, + 1494, + 1495, + 1499 + ], + "compressed_sha256": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "cut": 46568, + "donor_values": { + "1": "0", + "10": "0", + "1000": "0", + "1002": "0", + "1004": "0", + "1008": "0", + "1010": "0", + "1013": "0", + "1015": "0", + "1016": "0", + "1018": "0", + "1019": "0", + "102": "0", + "1020": "0", + "1022": "0", + "1027": "0", + "103": "0", + "1030": "0", + "1031": "0", + "1041": "0", + "105": "0", + "1053": "0", + "1057": "0", + "1060": "0", + "1062": "0", + "1070": "0", + "1077": "0", + "1078": "0", + "1080": "0", + "1081": "0", + "109": "0", + "1091": "0", + "1093": "0", + "1095": "0", + "1098": "0", + "110": "0", + "1100": "0", + "1105": "0", + "1106": "0", + "1109": "0", + "1110": "0", + "1112": "0", + "1113": "0", + "1125": "0", + "1126": "0", + "1127": "0", + "1128": "0", + "1129": "0", + "1132": "0", + "1136": "0", + "1137": "0", + "1148": "0", + "1153": "0", + "1155": "0", + "1157": "0", + "1161": "0", + "1162": "0", + "1164": "0", + "1168": "0", + "1170": "0", + "1172": "0", + "1173": "0", + "1175": "0", + "1178": "0", + "1182": "0", + "1183": "0", + "1184": "0", + "1187": "0", + "1188": "0", + "1193": "0", + "1196": "0", + "1197": "0", + "1200": "0", + "1203": "0", + "1204": "0", + "1205": "0", + "1206": "0", + "1207": "0", + "1208": "0", + "1240": "0", + "126": "0", + "1263": "0", + "1264": "0", + "1304": "0", + "1307": "0", + "1309": "0", + "1319": "0", + "1327": "0", + "1328": "0", + "1353": "0", + "1354": "0", + "1359": "0", + "1367": "0", + "1374": "0", + "1378": "0", + "1379": "0", + "1382": "0", + "1385": "0", + "1387": "0", + "1404": "0", + "1405": "0", + "1409": "0", + "1410": "0", + "1424": "0", + "1430": "0", + "1434": "0", + "1435": "0", + "1436": "0", + "1441": "0", + "1443": "0", + "1444": "0", + "1445": "0", + "1449": "0", + "1453": "0", + "1457": "0", + "1458": "0", + "1459": "0", + "1460": "0", + "1461": "0", + "1463": "0", + "1464": "0", + "1465": "0", + "1466": "0", + "1467": "0", + "1469": "0", + "1470": "0", + "1471": "0", + "1472": "0", + "1473": "0", + "1474": "0", + "1475": "0", + "1476": "0", + "1477": "0", + "1478": "0", + "1479": "0", + "1484": "0", + "1485": "0", + "1486": "0", + "1487": "0", + "1489": "0", + "1490": "0", + "1493": "0", + "1494": "0", + "1495": "0", + "1499": "0", + "151": "0", + "16": "0", + "17": "0", + "173": "0", + "18": "0", + "19": "0", + "20": "0", + "205": "0", + "21": "0", + "22": "0", + "226": "0", + "228": "0", + "230": "0", + "234": "0", + "236": "0", + "24": "0", + "240": "0", + "248": "0", + "249": "0", + "252": "0", + "254": "0", + "255": "0", + "256": "0", + "257": "0", + "263": "0", + "264": "0", + "267": "0", + "272": "0", + "274": "0", + "276": "0", + "279": "0", + "28": "0", + "280": "0", + "284": "0", + "285": "0", + "286": "0", + "288": "0", + "294": "0", + "295": "0", + "296": "0", + "297": "0", + "299": "0", + "3": "0", + "300": "0", + "303": "0", + "312": "0", + "315": "0", + "316": "0", + "319": "0", + "320": "0", + "328": "0", + "331": "0", + "332": "0", + "334": "0", + "338": "0", + "34": "0", + "340": "0", + "343": "0", + "344": "0", + "347": "0", + "348": "0", + "350": "0", + "352": "0", + "354": "0", + "358": "0", + "359": "0", + "363": "0", + "364": "0", + "365": "0", + "37": "0", + "376": "0", + "379": "0", + "38": "0", + "382": "0", + "392": "0", + "393": "0", + "395": "0", + "399": "0", + "402": "0", + "409": "0", + "415": "0", + "417": "0", + "421": "0", + "425": "0", + "43": "0", + "431": "0", + "436": "0", + "439": "0", + "440": "0", + "444": "0", + "446": "0", + "447": "0", + "448": "0", + "449": "0", + "460": "0", + "461": "0", + "464": "0", + "466": "0", + "468": "0", + "469": "0", + "470": "0", + "471": "0", + "472": "0", + "473": "0", + "475": "0", + "477": "0", + "478": "0", + "482": "0", + "484": "0", + "485": "0", + "489": "0", + "490": "0", + "494": "0", + "496": "0", + "5": "0", + "502": "0", + "504": "0", + "505": "0", + "506": "0", + "517": "0", + "518": "0", + "519": "0", + "52": "0", + "520": "0", + "523": "0", + "525": "0", + "526": "0", + "528": "0", + "53": "0", + "532": "0", + "54": "0", + "549": "0", + "553": "0", + "554": "0", + "56": "0", + "561": "0", + "566": "0", + "567": "0", + "569": "0", + "570": "0", + "571": "0", + "572": "0", + "573": "0", + "583": "0", + "586": "0", + "587": "0", + "589": "0", + "59": "0", + "590": "0", + "594": "0", + "595": "0", + "60": "0", + "608": "0", + "609": "0", + "610": "0", + "612": "0", + "613": "0", + "614": "0", + "617": "0", + "619": "0", + "620": "0", + "627": "0", + "635": "0", + "637": "0", + "643": "0", + "650": "0", + "651": "0", + "652": "0", + "653": "0", + "654": "0", + "655": "0", + "66": "0", + "660": "0", + "661": "0", + "662": "0", + "663": "0", + "664": "0", + "666": "0", + "667": "0", + "669": "0", + "67": "0", + "671": "0", + "672": "0", + "674": "0", + "676": "0", + "677": "0", + "679": "0", + "681": "0", + "682": "0", + "683": "0", + "684": "0", + "688": "0", + "689": "0", + "69": "0", + "695": "0", + "698": "0", + "7": "0", + "702": "0", + "704": "0", + "707": "0", + "709": "0", + "732": "0", + "735": "0", + "737": "0", + "738": "0", + "739": "0", + "743": "0", + "744": "0", + "745": "0", + "752": "0", + "758": "0", + "764": "0", + "770": "0", + "772": "0", + "773": "0", + "774": "0", + "775": "0", + "777": "0", + "779": "0", + "78": "0", + "781": "0", + "787": "0", + "789": "0", + "79": "0", + "791": "0", + "797": "0", + "800": "0", + "802": "0", + "806": "0", + "808": "0", + "812": "0", + "813": "0", + "819": "0", + "820": "0", + "821": "0", + "822": "0", + "823": "0", + "824": "0", + "825": "0", + "826": "0", + "832": "0", + "836": "0", + "837": "0", + "839": "0", + "840": "0", + "842": "0", + "843": "0", + "845": "0", + "848": "0", + "852": "0", + "853": "0", + "857": "0", + "859": "0", + "862": "0", + "865": "0", + "87": "0", + "870": "0", + "871": "0", + "872": "0", + "873": "0", + "875": "0", + "9": "0", + "92": "0", + "94": "0", + "97": "0", + "988": "0", + "990": "0", + "991": "0", + "992": "0", + "994": "0", + "995": "0", + "996": "0" + }, + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "key": [ + 43091, + 43093, + 46566 + ], + "kind": "separator", + "mutant_donor_values": { + "1": "791/516", + "10": "0", + "1000": "0", + "1002": "0", + "1004": "0", + "1008": "0", + "1010": "0", + "1013": "0", + "1015": "-791/258", + "1016": "0", + "1018": "0", + "1019": "0", + "102": "0", + "1020": "0", + "1022": "0", + "1027": "0", + "103": "0", + "1030": "0", + "1031": "0", + "1041": "-791/516", + "105": "0", + "1053": "-791/258", + "1057": "0", + "1060": "0", + "1062": "0", + "1070": "0", + "1077": "-791/344", + "1078": "0", + "1080": "0", + "1081": "0", + "109": "0", + "1091": "0", + "1093": "0", + "1095": "0", + "1098": "791/2064", + "110": "0", + "1100": "-1582/129", + "1105": "-791/258", + "1106": "0", + "1109": "-791/344", + "1110": "0", + "1112": "0", + "1113": "0", + "1125": "0", + "1126": "0", + "1127": "0", + "1128": "0", + "1129": "0", + "1132": "791/258", + "1136": "791/258", + "1137": "0", + "1148": "-791/1032", + "1153": "0", + "1155": "0", + "1157": "0", + "1161": "0", + "1162": "0", + "1164": "0", + "1168": "0", + "1170": "0", + "1172": "0", + "1173": "0", + "1175": "0", + "1178": "0", + "1182": "0", + "1183": "0", + "1184": "0", + "1187": "0", + "1188": "0", + "1193": "0", + "1196": "0", + "1197": "0", + "1200": "0", + "1203": "0", + "1204": "0", + "1205": "0", + "1206": "0", + "1207": "0", + "1208": "0", + "1240": "0", + "126": "0", + "1263": "0", + "1264": "0", + "1304": "0", + "1307": "0", + "1309": "-791/2064", + "1319": "0", + "1327": "0", + "1328": "0", + "1353": "0", + "1354": "0", + "1359": "0", + "1367": "0", + "1374": "0", + "1378": "-791/516", + "1379": "0", + "1382": "0", + "1385": "0", + "1387": "0", + "1404": "0", + "1405": "0", + "1409": "0", + "1410": "0", + "1424": "0", + "1430": "0", + "1434": "0", + "1435": "0", + "1436": "0", + "1441": "0", + "1443": "0", + "1444": "0", + "1445": "0", + "1449": "791/1032", + "1453": "0", + "1457": "0", + "1458": "0", + "1459": "0", + "1460": "0", + "1461": "0", + "1463": "0", + "1464": "0", + "1465": "0", + "1466": "0", + "1467": "0", + "1469": "0", + "1470": "0", + "1471": "0", + "1472": "0", + "1473": "0", + "1474": "0", + "1475": "0", + "1476": "0", + "1477": "0", + "1478": "0", + "1479": "0", + "1484": "0", + "1485": "0", + "1486": "0", + "1487": "0", + "1489": "0", + "1490": "0", + "1493": "0", + "1494": "0", + "1495": "0", + "1499": "0", + "151": "0", + "16": "0", + "17": "0", + "173": "791/516", + "18": "0", + "19": "-791/1032", + "20": "0", + "205": "791/258", + "21": "0", + "22": "0", + "226": "0", + "228": "0", + "230": "0", + "234": "0", + "236": "0", + "24": "-791/516", + "240": "0", + "248": "0", + "249": "0", + "252": "-791/516", + "254": "-791/516", + "255": "0", + "256": "0", + "257": "0", + "263": "0", + "264": "791/516", + "267": "0", + "272": "0", + "274": "0", + "276": "791/258", + "279": "0", + "28": "0", + "280": "-791/1032", + "284": "0", + "285": "0", + "286": "0", + "288": "0", + "294": "0", + "295": "791/258", + "296": "-791/1032", + "297": "0", + "299": "0", + "3": "-791/516", + "300": "0", + "303": "0", + "312": "791/258", + "315": "791/258", + "316": "0", + "319": "0", + "320": "0", + "328": "791/1032", + "331": "0", + "332": "791/1032", + "334": "0", + "338": "791/516", + "34": "0", + "340": "0", + "343": "0", + "344": "0", + "347": "0", + "348": "0", + "350": "0", + "352": "0", + "354": "0", + "358": "0", + "359": "0", + "363": "0", + "364": "0", + "365": "0", + "37": "0", + "376": "791/1032", + "379": "0", + "38": "791/1032", + "382": "0", + "392": "0", + "393": "0", + "395": "0", + "399": "0", + "402": "0", + "409": "0", + "415": "0", + "417": "0", + "421": "0", + "425": "0", + "43": "0", + "431": "0", + "436": "791/258", + "439": "0", + "440": "0", + "444": "0", + "446": "0", + "447": "0", + "448": "0", + "449": "0", + "460": "-791/258", + "461": "0", + "464": "791/258", + "466": "791/258", + "468": "0", + "469": "0", + "470": "0", + "471": "0", + "472": "0", + "473": "0", + "475": "0", + "477": "0", + "478": "0", + "482": "-791/516", + "484": "0", + "485": "0", + "489": "0", + "490": "791/516", + "494": "0", + "496": "0", + "5": "0", + "502": "0", + "504": "0", + "505": "0", + "506": "0", + "517": "0", + "518": "0", + "519": "0", + "52": "0", + "520": "0", + "523": "791/258", + "525": "791/258", + "526": "0", + "528": "0", + "53": "0", + "532": "0", + "54": "0", + "549": "-791/258", + "553": "0", + "554": "-791/516", + "56": "0", + "561": "0", + "566": "0", + "567": "0", + "569": "0", + "570": "0", + "571": "0", + "572": "0", + "573": "0", + "583": "0", + "586": "0", + "587": "0", + "589": "0", + "59": "0", + "590": "0", + "594": "0", + "595": "0", + "60": "0", + "608": "791/258", + "609": "0", + "610": "0", + "612": "0", + "613": "791/258", + "614": "0", + "617": "791/258", + "619": "0", + "620": "0", + "627": "0", + "635": "0", + "637": "0", + "643": "0", + "650": "791/1032", + "651": "0", + "652": "0", + "653": "0", + "654": "0", + "655": "791/516", + "66": "0", + "660": "-791/516", + "661": "0", + "662": "-791/1032", + "663": "-791/516", + "664": "0", + "666": "0", + "667": "0", + "669": "791/1032", + "67": "0", + "671": "0", + "672": "0", + "674": "0", + "676": "0", + "677": "0", + "679": "0", + "681": "0", + "682": "0", + "683": "0", + "684": "0", + "688": "0", + "689": "0", + "69": "0", + "695": "0", + "698": "0", + "7": "0", + "702": "0", + "704": "791/1032", + "707": "0", + "709": "0", + "732": "0", + "735": "0", + "737": "0", + "738": "0", + "739": "0", + "743": "0", + "744": "0", + "745": "0", + "752": "-791/129", + "758": "0", + "764": "0", + "770": "0", + "772": "0", + "773": "0", + "774": "0", + "775": "0", + "777": "0", + "779": "791/129", + "78": "0", + "781": "0", + "787": "0", + "789": "0", + "79": "791/516", + "791": "0", + "797": "0", + "800": "0", + "802": "0", + "806": "0", + "808": "0", + "812": "791/258", + "813": "0", + "819": "-791/516", + "820": "0", + "821": "0", + "822": "0", + "823": "0", + "824": "0", + "825": "-791/2064", + "826": "0", + "832": "0", + "836": "0", + "837": "0", + "839": "-791/129", + "840": "0", + "842": "0", + "843": "0", + "845": "-1582/129", + "848": "0", + "852": "0", + "853": "0", + "857": "0", + "859": "0", + "862": "0", + "865": "0", + "87": "0", + "870": "0", + "871": "0", + "872": "0", + "873": "0", + "875": "0", + "9": "-791/129", + "92": "0", + "94": "0", + "97": "0", + "988": "0", + "990": "0", + "991": "0", + "992": "-791/344", + "994": "0", + "995": "0", + "996": "791/172" + }, + "mutant_drop_coordinate": 1, + "mutant_source_value": "1", + "runner_cap_seconds": 20, + "source_value": "1", + "uncompressed_sha256": "9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" +} diff --git a/research/p104-chart127-delayed-bank-separators/receipts/R221-LEAD-COMPARISON.json b/research/p104-chart127-delayed-bank-separators/receipts/R221-LEAD-COMPARISON.json new file mode 100644 index 0000000000..f487f63148 --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/receipts/R221-LEAD-COMPARISON.json @@ -0,0 +1,25 @@ +{ + "bank_rank": 417, + "cut": 46568, + "gross": [ + "858321385403521186417773068802270342529599338507/10000000000000000000000000000000000000000000000000", + "858321385403521186417773068802272693280582759269/10000000000000000000000000000000000000000000000000" + ], + "key": [ + 43091, + 43093, + 46566 + ], + "lead_result_sha256": "2685700a4c39ba2994ba71cd8a810644d5600024f1a6d5c6217974a7cbf43059", + "rank_split": [ + 1, + 1, + 2 + ], + "roles": 417, + "source_values": [ + "1", + "1" + ], + "violating_mutant_donors": 65 +} diff --git a/research/p104-chart127-delayed-bank-separators/replay.py b/research/p104-chart127-delayed-bank-separators/replay.py new file mode 100644 index 0000000000..178fe464bf --- /dev/null +++ b/research/p104-chart127-delayed-bank-separators/replay.py @@ -0,0 +1,69 @@ +"""Replay the final two delayed chart-127 exclusions and directed prices.""" +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 +CASES = { + 220: ([40430,40432,46222], 46224, 298, [4,2,6], 8, 90), + 221: ([43091,43093,46566], 46568, 417, [1,1,2], 157, 65), +} + + +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 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 + + h = run_path(str(ROOT / "engines/pricing.py"))["power_bounds"] + lo, hi = map(F, ("0.00364665195644044790699554028334161", "0.00364665195644044790699554028334162")) + total_upper = F(0) + for n, (key, cut, donor_count, ranks, support, bad_count) in CASES.items(): + certificate_path = f"receipts/R{n}-CERTIFICATE.json" + certificate = read(certificate_path) + lead = read(f"receipts/R{n}-LEAD-COMPARISON.json") + output = run([executable, "-I", "-B", str(ROOT / "engines/scalar.py"), + str(ROOT / "inputs/7334-WORD.json.gz"), str(ROOT / certificate_path)], + check=True, capture_output=True, timeout=22).stdout + actual = loads(output, object_pairs_hook=unique) + assert actual == read(f"receipts/R{n}-INDEPENDENT.json") + assert lead["key"] == certificate["key"] == actual["key"] == key + assert lead["cut"] == certificate["cut"] == actual["cut"] == cut + assert lead["roles"] == len(actual["chart_bank"]) == donor_count + assert len(certificate["input"]) == support + assert [actual["source_value"], actual["mutant_source_value"]] == lead["source_values"] == ["1","1"] + assert set(actual["donor_values"].values()) == {"0"} + assert sum(v != "0" for v in actual["mutant_donor_values"].values()) == lead["violating_mutant_donors"] == bad_count + assert lead["rank_split"] == ranks + a, b, ab = ranks + lower = 17 * (h(a, hi)[0] + h(b, hi)[0] - h(ab, lo)[1]) + upper = 17 * (h(a, lo)[1] + h(b, lo)[1] - h(ab, hi)[0]) + assert [lower, upper] == list(map(F, lead["gross"])) + assert 0 < lower < upper < 1 + total_upper += upper + assert total_upper < F("0.3214") + print("PASS_CHART127_DELAYED_BANKS: 2 cuts, all 715 donor values zero, both mutants rejected") + + +if __name__ == "__main__": + main()