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-one-entrant-delayed-correction-bound/NOTICE.md b/research/p104-one-entrant-delayed-correction-bound/NOTICE.md new file mode 100644 index 0000000000..1edd43a9e3 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/NOTICE.md @@ -0,0 +1 @@ +The exact native word and caller derive from #7334 and #7113. #7434 supplies the inventory, historical fixed-ADD chronology and first exact controls. #7436 supplies historical separators and their independent replays. See README.md and PROVENANCE.json for exact credits. OpenAI Codex and subagents materially assisted this package. diff --git a/research/p104-one-entrant-delayed-correction-bound/PINS.txt b/research/p104-one-entrant-delayed-correction-bound/PINS.txt new file mode 100644 index 0000000000..9b4ba0da0c --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/PINS.txt @@ -0,0 +1,15 @@ +14f0a29de7d7e8aa8167992a86d281cca364153c8823011be0bf57342130edfa engines/LEAD-PINS.txt +4c9b80ca4547ab0fb8b32a4ace9570010cee386905c5ea4b18e2e53deedd5c7d engines/alternate.py +2473a420c26d0d95c0c233dff7f3fc443647ecbdee3fd9a91cdf623300a44e55 engines/augmented.py +4f554f1a98411eccd134d1029408c6ee76b280a8a0f90dd17dc3edae200b841d engines/bank_gate.py +247fb32afea034e934441934d117fceb57edeeecb4ae11a1b9e6e88b0d6bf420 engines/engine206.py +2b9f7a802d5af6152ad5b61ae5d001b8f3cb8fff4ff671046d2a047855369e1c engines/independent207.py +f8985bebcf80d12d59c6d74515d15ee56bbfee4406f8fb4fda76b46b6f8fe9c5 engines/lead207.py +e3a281ef603a4b37eb1f6a40371a04bbba6c86fa989aa4a068c3f9f5dc6c3424 engines/peel.py +4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a inputs/7334-WORD.json.gz +33ba19c30803c39391a23dd8156f55fa06bcd6d3f0553c085ea5b5f0b314cb18 inputs/R200.json +502266e23fd2a12c56ae9c0e2f407882a7681be87be66242922ed573469df1f1 inputs/R203-INDEPENDENT.json +af65239ef51b778802a02d5c0b1042890d308bfbc479e47e6c2e28e47f22978c inputs/R203-LEAD.json +3e29bd164c607b33df2dac277cad2f9b9bf8fb0848dba269f09ddd483b8d6ce3 inputs/R204.json +3ec370aca6fbf18001874c76dfe7c2a07dfe2752378e1019432bddd11bcf94fc inputs/STAGE1.json.gz +6de2686c00d1682065fec128f7cc1938a646ebb72f1895c38babb72e7bbb7d6d inputs/STAGE2.json diff --git a/research/p104-one-entrant-delayed-correction-bound/PROOF.md b/research/p104-one-entrant-delayed-correction-bound/PROOF.md new file mode 100644 index 0000000000..fe0235f30c --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/PROOF.md @@ -0,0 +1,13 @@ +# Exact scope and separating inputs + +For each historical key, the old source row is evaluated immediately before its old ADD. From the second MOVE, advance to immediately before the next operation that touches the target role as an operand, counting both sources and destinations of ADD and COPY. The bank consists of roles other than the target resident in its destination chart at that cut. The exact trace tracks INIT, CLEAR, SCALE, COPY, ADD and MOVE. It treats MOVE as a chart change of a normalized row. + +The inventory is one #7434 coordinate exclusion, six #7434 exact controls, 62 #7436 small-bank exclusions and 50 #7436 larger-bank exclusions. The 119-case scan has a 25-second cap. It exhausts the scope with no literal proportional donor and 118 coordinate survivors. There are 106 unchanged cuts and 13 cuts advanced past precisely one intervening MOVE. In every advanced cut the intervening MOVE brings one distinct donor into the target chart without changing an old bank row. No case uses the word-end convention. + +An old covector can be reused exactly when its value on the entrant is zero. It already annihilates the old bank and is nonzero on the same pre-ADD source. A nonzero value on the entrant invalidates that particular certificate and leaves the augmented span question open. This test is necessary for reusing the old certificate and sufficient for excluding the augmented bank when it passes. + +The first span gate capped its scope at three cases and its runner time at 30 seconds. It solved all three. Two had unchanged cuts. The moved case `[38956,38957,43320]` has rank three and separator `x2+x32`, with source value one. The 12 remaining moved cases were evaluated with both older exact-certificate sets, each at a 20-second entrant cap. The old certificate sets give six and seven exclusions, respectively. At `[42061,42063,43484]` the first certificate takes value −1/2 on entrant 238. The alternate certificate `x1287+x1340/8` annihilates all five augmented bank rows and gives source value −1/4. The independent and lead traces check this alternate certificate through different representations. The remaining four open cases are listed in the README. + +After the entrant screen, the 30-second one-case span gate selected `[40396,40398,46023]`, using the directed old price and then bank size. Its optimistic raw moment saving was approximately 0.23556026777. Its bank contains 203 rows including entrant 417. Two implementations give rank 203 and independently recover the exact separating input with source value one. The full signed values are reproduced by the pinned replay, whose result digest binds all bank decisions and coefficients. + +The exclusions apply to a single unchanged paid itinerary and the exact delayed cut defined here. Different charts, paid sites, banks, source snapshots, or multi-cut constructions need fresh proofs. Price is inherited from the historical two-MOVE relaxation. No fully charged component saving or κ gain is certified. diff --git a/research/p104-one-entrant-delayed-correction-bound/PROVENANCE.json b/research/p104-one-entrant-delayed-correction-bound/PROVENANCE.json new file mode 100644 index 0000000000..3290f637c3 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/PROVENANCE.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "comparator": { + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7334", + "head": "aaeec8c0acf01e99a5f331ef363a698d9c084ace", + "word": "research/p104-helper-319-fused-return/WORD.json.gz", + "word_sha256": "4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "uncompressed_sha256": "9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" + }, + "caller": { + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7113", + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d" + }, + "historical_inventory": { + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7434", + "head": "5f45414d0cc5d0ce6931167bc3e54b026fd4ca09", + "receipt_path": "research/p104-historical-bank-move-fusion-bound/receipts/EXPECTED.json", + "stage1_uncompressed_sha256": "ae434c63bfc6e28ae3374d246ad086def96ed3dc8ddba3e759eb60af391bfadc", + "stage2_sha256": "6de2686c00d1682065fec128f7cc1938a646ebb72f1895c38babb72e7bbb7d6d", + "bank_engine_path": "research/p104-historical-bank-move-fusion-bound/engines/bank_gate.py", + "r200_note": "The bundled R200 receipt is the historical run's original format. The #7434 public package regenerates its own R200 receipt with additional provenance. This replay directly tests the R200 coordinate obstruction." + }, + "historical_exclusions": { + "source": "https://github.com/CrocSwap/integer-mult-bounds/pull/7436", + "head": "2af3f4d5eb28d2f33db7ddab25503322ba88b5e6", + "package": "research/p104-historical-bank-span-continuation", + "receipt_map": { + "inputs/R203-INDEPENDENT.json": "receipts/R203-REVERSE.json", + "inputs/R203-LEAD.json": "receipts/R203-FORWARD.json", + "inputs/R204.json": "receipts/R204-LEAD.json" + } + } +} diff --git a/research/p104-one-entrant-delayed-correction-bound/README.md b/research/p104-one-entrant-delayed-correction-bound/README.md new file mode 100644 index 0000000000..c4afbfd097 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/README.md @@ -0,0 +1,20 @@ +# Bound one-entrant delayed correction banks + +This source-bound exclusion concerns the exact [#7334 native word](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) at `aaeec8c0acf01e99a5f331ef363a698d9c084ace` and [#7113 caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) at `07a76c5e2738882c0cb322278e56f6cae3c9885d`. Keep the omitted source at its old pre-ADD value and ask whether it belongs to the bank at the latest cut before the next target-role operand contact. Keep all other paid positions and charts fixed. The correction may use any rational combination of the available bank rows. + +Of 119 historically excluded banks, 106 cuts stay unchanged and 13 gain one donor. The unchanged exclusions carry over. Seven moved banks inherit a valid separating input, and two more moved banks fail exact span checks. No literal proportional donor passed. The four remaining cases are unresolved. The complete bound and κ are unchanged. + +Use CPython 3.12 on POSIX. From the checkout root: + +```sh +python3.12 -I -B research/p104-one-entrant-delayed-correction-bound/replay.py +``` + +The replay reads bundled, hash-pinned inputs and writes only to a fresh temporary directory. It uses the standard library and needs no network, prior temporary state, or external checkout. Expected output is `PASS_DELAYED_BANK: 119 surveyed, 115 exact exclusions, 4 unresolved`. + +## Open next questions + + +The open cases are `[41805,41807,43313]`, `[41944,41946,43419]`, `[40430,40432,46222]`, and `[43091,43093,46566]`. Start with exact quotient span at `[41805,41807,43313]` under a 30-second solver cap. An exact span survivor would still need admissible scalars, a literal corrected word, ownership and restoration checks, and a fully charged invoice. + +[#7434](https://github.com/CrocSwap/integer-mult-bounds/pull/7434) supplied the fixed historical chronology, candidate inventory and first exact controls. [#7436](https://github.com/CrocSwap/integer-mult-bounds/pull/7436) supplied the two older exact methods and their separating inputs. [#7334](https://github.com/CrocSwap/integer-mult-bounds/pull/7334) and [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) supplied the exact native word and caller lineage. Codex and subagents materially assisted the proof, code, replay and packaging. diff --git a/research/p104-one-entrant-delayed-correction-bound/SOURCES.json b/research/p104-one-entrant-delayed-correction-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "path": "certificates/selected-result.json", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1", + "usage": "provenance" + }, + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + } + ], + "schema_version": 1 +} diff --git a/research/p104-one-entrant-delayed-correction-bound/TASK.json b/research/p104-one-entrant-delayed-correction-bound/TASK.json new file mode 100644 index 0000000000..5ed4fcb3b8 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7334/#7113 and 119 pinned prior exclusions. Advance each historical cut to immediately before the next target-role operand contact; changed cuts add precisely one bank donor.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent verification and packaging.", + "author": "P104 one-entrant delayed correction banks", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "Two paid MOVEs are only removable if the omitted source can be supplied at the delayed cut without another paid call.", + "budget_minutes": 12, + "evidence": "115 exclusions, including seven moved banks that inherit exact certificates and two newly solved moved banks; four named unresolved.", + "open_questions": [ + { + "blocked_by": "The selected one-bank exact solve excluded its key; other spans were outside the cap.", + "first_step": "Evaluate exact quotient span at [41805,41807,43313] under a 30-second cap.", + "question": "Does the omitted source lie in any of the four unresolved enlarged banks?", + "why_it_matters": "An exact witness could justify testing coefficient legality and the fully charged two-MOVE contraction." + } + ], + "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": "Check whether delaying to the last observer-free cut defeats the previous historical bank exclusions.", + "scope_status": "changed", + "stop_rule": "119 surveys/25 seconds; up to three spans/30 seconds; 12 entrant certificates/20 seconds per implementation and one exact augmented span/30 seconds.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-one-entrant-delayed-correction-bound/VERIFICATION.md b/research/p104-one-entrant-delayed-correction-bound/VERIFICATION.md new file mode 100644 index 0000000000..0301774845 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/VERIFICATION.md @@ -0,0 +1,15 @@ +# Verification + +Run the command in the README with CPython 3.12. The launcher checks path-keyed SHA-256 input and engine hashes in `PINS.txt`, rejects duplicate paths, expands the bundled Stage 1 receipt, and reconstructs the following outputs. The embedded hashes bind exact receipts, including test keys and rational covectors. + +| Receipt | SHA-256 | +| --- | --- | +| 119-case scan and three exact spans | `a5ad6b1d6a0aeb376ca9b945de03f44e40fb177225133b0fdd3a6466313b2fa3` | +| Independent 12 entrant tests and one augmented span | `1c2193b302e6ec8e26d755c03e6c7e462cd3fb44af9d73dad438834a0a900ac6` | +| Lead 12 entrant tests | `f2af3d476dd24e49653b7bff45276d308a3067aa2bfc86cdef7c24bcff79d2a3` | +| Lead rank-203 augmented span | `125ee63c390ec7a62bce9d14181bd4b66cfc0fcd89e1d48ef396cc7a93ec3ef2` | +| Lead alternate separating input | `72d244dc76debc2fd46f1b8d1c205a4b1179daa3d2c2bd463d2177b1d0544dbd` | + +Each completed scientific runner exits zero. The 119-case survey, three-case first span scope, and 12-case entrant gate exhausted their frozen scopes before their time limits. The single augmented solve exhausted its one-case scope. Four other augmented spans were outside the case cap. The replay also requires rejection of a deliberately changed frozen cut receipt. + +The older exclusions are authenticated predecessor inputs. Their full recomputation belongs to the independently runnable #7434 and #7436 predecessor packages. Hosted checks are tracked on the exact PR head when opened. Full candidate verification does not apply because the tests produced no candidate. diff --git a/research/p104-one-entrant-delayed-correction-bound/VERIFY.json b/research/p104-one-entrant-delayed-correction-bound/VERIFY.json new file mode 100644 index 0000000000..ab632001cd --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/VERIFY.json @@ -0,0 +1,19 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "checks": "Reproduce the fixed-cut survey, both entrant tests, two exact augmented-span implementations, the alternate separator, and corrupted-receipt rejection.", + "timeout_seconds": 190 + } + ], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-one-entrant-delayed-correction-bound/engines/LEAD-PINS.txt b/research/p104-one-entrant-delayed-correction-bound/engines/LEAD-PINS.txt new file mode 100644 index 0000000000..13831236eb --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/engines/LEAD-PINS.txt @@ -0,0 +1,5 @@ +4f554f1a98411eccd134d1029408c6ee76b280a8a0f90dd17dc3edae200b841d bank_gate.py +4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a inputs/7334-WORD.json.gz +af65239ef51b778802a02d5c0b1042890d308bfbc479e47e6c2e28e47f22978c inputs/R203.json +3e29bd164c607b33df2dac277cad2f9b9bf8fb0848dba269f09ddd483b8d6ce3 inputs/R204.json +a5ad6b1d6a0aeb376ca9b945de03f44e40fb177225133b0fdd3a6466313b2fa3 inputs/R206.json diff --git a/research/p104-one-entrant-delayed-correction-bound/engines/alternate.py b/research/p104-one-entrant-delayed-correction-bound/engines/alternate.py new file mode 100644 index 0000000000..eea28060c3 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/engines/alternate.py @@ -0,0 +1,46 @@ +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +from json import dumps,loads +from pathlib import Path +from runpy import run_path +R=Path(__file__).resolve().parent +b=run_path(str(R/"bank_gate.py")) +add,scalar=b["add"],b["scalar"] +def trace(w): + n,m=w["public"],w["owned_fields"] + rows=[{i:Q(1)} for i in range(n)]+[{} for _ in range(m)] + charts=w["initial"]+[None]*m + for i,(op,r,*a) in enumerate(w["program"][:43486]): + if i==42063: + source=rows[67].copy() + if op=="MOVE": + assert charts[r]==a[0] + charts[r]=a[1] + elif op=="INIT": + assert charts[r] is None and not rows[r] + charts[r]=a[0] + elif op=="CLEAR": + assert charts[r]==a[0] + charts[r]=None + rows[r].clear() + elif op=="SCALE": + assert charts[r]==a[1] + rows[r]={j:x*scalar(a[0]) for j,x in rows[r].items()} + else: + s,k,c=a + assert op in ("ADD","COPY") and charts[r]==charts[s]==c and r!=s + assert op!="COPY" or not rows[r] + add(rows[r],rows[s],scalar(k)) + return source,{i:rows[i] for i,c in enumerate(charts) if c==930 and i!=117} + + +raw=(R/"inputs/7334-WORD.json.gz").read_bytes() +assert sha256(raw).hexdigest()==b["PINS"]["inputs/7334-WORD.json.gz"] +target,bank=trace(loads(decompress(raw))) +probe={1287:Q(1),1340:Q(1,8)} +def dot(row): + return sum(row.get(j,0)*a for j,a in probe.items()) +assert len(bank)==5 and 238 in bank and all(not dot(row) for row in bank.values()) and dot(target) +print(dumps({"clocks":[42061,42063,43484],"probe":probe,"entrant":238, + "bank_count":len(bank),"target_value":dot(target)},default=str,sort_keys=True)) diff --git a/research/p104-one-entrant-delayed-correction-bound/engines/augmented.py b/research/p104-one-entrant-delayed-correction-bound/engines/augmented.py new file mode 100644 index 0000000000..985a6b9be0 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/engines/augmented.py @@ -0,0 +1,55 @@ +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +from json import dumps,loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM,alarm,signal +R=Path(__file__).resolve().parent +b=run_path(str(R/"bank_gate.py")) +add,scalar,solve=b["add"],b["scalar"],b["solve"] +test=run_path(str(R/"peel.py"))["test"] +def trace(w): + n,m=w["public"],w["owned_fields"] + rows=[{i:Q(1)} for i in range(n)]+[{} for _ in range(m)] + charts=w["initial"]+[None]*m + for i,(op,r,*a) in enumerate(w["program"][:46025]): + if i==40398: + source=rows[980].copy() + if op=="MOVE": + assert charts[r]==a[0] + charts[r]=a[1] + elif op=="INIT": + assert charts[r] is None and not rows[r] + charts[r]=a[0] + elif op=="CLEAR": + assert charts[r]==a[0] + charts[r]=None + rows[r].clear() + elif op=="SCALE": + assert charts[r]==a[1] + rows[r]={j:x*scalar(a[0]) for j,x in rows[r].items()} + else: + s,k,c=a + assert op in ("ADD","COPY") and charts[r]==charts[s]==c and r!=s + assert op!="COPY" or not rows[r] + add(rows[r],rows[s],scalar(k)) + return source,{i:rows[i] for i,c in enumerate(charts) if c==127 and i!=822} + + +def stop(*_): + raise TimeoutError("30-second single augmented bank cap") +signal(SIGALRM,stop) +alarm(30) +raw=(R/"inputs/7334-WORD.json.gz").read_bytes() +assert sha256(raw).hexdigest()==b["PINS"]["inputs/7334-WORD.json.gz"] +w=loads(decompress(raw)) +target,bank=trace(w) +assert len(bank)==203 and 417 in bank +rank,single,sep=test(target,bank) +coeff=None +if sep is None: + _,coeff,_=solve(target,bank) +alarm(0) +print(dumps({"clocks":[40396,40398,46023],"rank":rank,"singletons":single, + "seconds_cap":30,"separator":sep,"coefficients":coeff},sort_keys=True,indent=2,default=str)) diff --git a/research/p104-one-entrant-delayed-correction-bound/engines/bank_gate.py b/research/p104-one-entrant-delayed-correction-bound/engines/bank_gate.py new file mode 100644 index 0000000000..f44295271f --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/engines/bank_gate.py @@ -0,0 +1,134 @@ +"""Check the exact final-chart bank for one paid public MOVE fusion.""" +from fractions import Fraction as Q +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 + +ROOT=Path(__file__).resolve().parent +PINS={"inputs/7334-WORD.json.gz":"4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "inputs/BANK.json":"4843481ba524572696ac5977182dfe55768c2746c8d5dbf59ee7ba7ee6feeffb"} +RAW="9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" + + +@cache +def scalar(text): + return Q(text) + + +def timeout(*_): + raise TimeoutError("20-second exact bank gate") + + +def add(a,b,c): + for j,v in b.items(): + x=a.get(j,0)+c*v + if x: + a[j]=x + else: + a.pop(j,None) + + +def trace(w): + n,m=w["public"],w["owned_fields"] + rows=[{i:Q(1)} for i in range(n)]+[{} for _ in range(m)] + charts=w["initial"]+[None]*m + for i,(op,r,*a) in enumerate(w["program"][:48768]): + if i==48766: + assert charts[1561]==306 + source=rows[1561].copy() + if op=="MOVE": + assert charts[r]==a[0] + charts[r]=a[1] + elif op=="INIT": + assert charts[r] is None and not rows[r] + charts[r]=a[0] + elif op=="CLEAR": + assert charts[r]==a[0] + charts[r]=None + rows[r].clear() + elif op=="SCALE": + assert charts[r]==a[1] + rows[r]={j:x*scalar(a[0]) for j,x in rows[r].items()} + else: + s,k,c=a + assert op in ("ADD","COPY") and charts[r]==charts[s]==c and r!=s + assert op!="COPY" or not rows[r] + add(rows[r],rows[s],scalar(k)) + return source,{i:rows[i] for i,c in enumerate(charts) if c==127 and i!=1034} + + +def solve(target,bank): + piv={} + for i,row in sorted(bank.items(),key=lambda t:(len(t[1]),t[0])): + v=row.copy() + uses={i:Q(1)} + # Eliminate any existing pivot, from lowest coordinate upward. + while True: + k=min((j for j in v if j in piv),default=None) + if k is None: + break + row,history=piv[k] + a=v[k] + add(v,row,-a) + add(uses,history,-a) + if v: + k=min(v) + den=v[k] + piv[k]=({j:x/den for j,x in v.items()}, + {j:x/den for j,x in uses.items()}) + v=target.copy() + answer={} + for j,(row,history) in sorted(piv.items()): + if j in v: + a=v[j] + add(v,row,-a) + add(answer,history,a) + if not v: + check={} + for j,c in answer.items(): + add(check,bank[j],c) + assert check==target + return len(piv),answer,None + k=min(v) + x={k:Q(1)} + for j,(row,_) in sorted(piv.items(),reverse=True): + a=-sum(v*x.get(i,0) for i,v in row.items() if i!=j) + if a: + x[j]=a + def dot(row): + return sum(c*x.get(j,0) for j,c in row.items()) + assert all(not dot(row) for row in bank.values()) + assert dot(target)==v[k]!=0 + return len(piv),None,{"input":x,"source_value":dot(target)} + + +def main(): + assert __debug__ + signal(SIGALRM,timeout) + alarm(20) + for p,h in PINS.items(): + assert sha256((ROOT/p).read_bytes()).hexdigest()==h + raw=decompress((ROOT/"inputs/7334-WORD.json.gz").read_bytes()) + assert sha256(raw).hexdigest()==RAW + w=loads(raw) + price=loads((ROOT/"inputs/BANK.json").read_bytes()) + assert len(w["program"])==76466 and w["public"]==1501 + assert w["program"][48765:48768]==price["frozen_historical_bank_candidate"]["events"] + assert Q(price["price_interval_17_calls"][0])>0 + source,bank=trace(w) + assert len(bank)==760 and sorted(bank)==price["after_second_move_bank"] + assert solve({1:Q(2)},{0:{1:Q(1)}})[1]=={0:Q(2)} + assert solve({2:Q(1)},{0:{1:Q(1)}})[2]["source_value"]==1 + rank,coeff,separator=solve(source,bank) + alarm(0) + print(dumps({"head":price["head"],"caller":price["caller"],"pins":PINS,"source":source, + "bank_role_count":len(bank),"bank_rank":rank,"post_move_cut":48768, + "case_cap":1,"seconds_cap":20,"coefficients":coeff,"separator":separator, + "survives":coeff is not None},indent=2,sort_keys=True,default=str)) + + +if __name__=="__main__": + main() diff --git a/research/p104-one-entrant-delayed-correction-bound/engines/engine206.py b/research/p104-one-entrant-delayed-correction-bound/engines/engine206.py new file mode 100644 index 0000000000..cef80f0eec --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/engines/engine206.py @@ -0,0 +1,274 @@ +"""Independently screen exact owner-free latest-cut banks and bounded spans.""" +from bisect import bisect_right +from collections import defaultdict +from fractions import Fraction as Q +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 + +ROOT=Path(__file__).resolve().parent +PINS={ + "inputs/7334-WORD.json.gz":"4b9fd1187b34ed97c3ac0c760d73531735a5d0ebc5b4d4ab4377160b20d9bb2a", + "inputs/R200.json":"33ba19c30803c39391a23dd8156f55fa06bcd6d3f0553c085ea5b5f0b314cb18", + "inputs/STAGE1.json":"ae434c63bfc6e28ae3374d246ad086def96ed3dc8ddba3e759eb60af391bfadc", + "inputs/STAGE2.json":"6de2686c00d1682065fec128f7cc1938a646ebb72f1895c38babb72e7bbb7d6d", + "inputs/R203.json":"502266e23fd2a12c56ae9c0e2f407882a7681be87be66242922ed573469df1f1", + "inputs/R204.json":"3e29bd164c607b33df2dac277cad2f9b9bf8fb0848dba269f09ddd483b8d6ce3", +} +HEAD="aaeec8c0acf01e99a5f331ef363a698d9c084ace" +CALLER="07a76c5e2738882c0cb322278e56f6cae3c9885d" +PAYLOAD="9aa8d6b054ba7eb2289d052c1079b16be518d2f0fbfb244569fa18e3733acdac" + + +def unique(items): + d=dict(items) + assert len(d)==len(items) + return d + + +def read(name): + path=f"inputs/{name}" + raw=(ROOT/path).read_bytes() + assert sha256(raw).hexdigest()==PINS[path],path + return raw + + +def json(name): + return loads(read(name),object_pairs_hook=unique) + + +@cache +def q(value): + return Q(value) + + +def stop(*_): + raise TimeoutError("bounded latest-cut gate") + + +def touch(e): + return e[1:3] if e[0] in ("ADD","COPY") else e[1:2] + + +def freeze(w): + r200,stage1,stage2,r203,r204=[json(x+".json") for x in ("R200","STAGE1","STAGE2","R203","R204")] + assert (r200["head"],r200["caller"])==(stage1["head"],stage1["caller"])==(stage2["head"],stage2["caller"])==(r203["head"],r203["caller"])==(HEAD,CALLER) + assert len(stage1["records"])==967 and len(stage1["screen_survivors"])==243 + first=[x["clocks"] for x in stage1["records"] if x["clocks"][-1]+1==r200["post_move_cut"]] + groups={"R200":first,"R201":stage2["frozen_keys"],"R203":[c["clocks"] for c in r203["checked"]], + "R204":[c["clocks"] for c in r204["records"] if c["separator"] is not None]} + assert [len(x) for x in groups.values()]==[1,6,62,50] + origins={tuple(key):origin for origin,keys in groups.items() for key in keys} + assert len(origins)==119 + cases={tuple(row["clocks"]):row for row in stage1["records"] if tuple(row["clocks"]) in origins} + assert set(cases)==set(origins) and cases[tuple(first[0])]["target_row"]==r200["source"] + watched={c["role"] for c in cases.values()} + tape=w["program"] + contacts=defaultdict(list) + for t,e in enumerate(tape): + for r in watched.intersection(touch(e)): + contacts[r].append(t) + for key,c in cases.items(): + a,b,d=key + owner,peer,chart=c["role"],c["peer"],c["chart"] + assert tape[a][:2]==["MOVE",owner] and tape[b][:3]==["ADD",owner,peer] + assert tape[d][0:2]==["MOVE",owner] and tape[d][3]==chart + j=bisect_right(contacts[owner],d) + assert tuple(contacts[owner][j-3:j])==key + c["cut"]=contacts[owner][j] if jd + c["old_origin"]=origins[key] + assert q(c["gross"][0])>0 + return cases + + +def axpy(dst,src,c): + for i,v in src.items(): + z=dst.get(i,0)+c*v + if z: + dst[i]=z + else: + dst.pop(i,None) + + +def proportional(target,row): + if target.keys()!=row.keys(): + return None + pivot=min(target) + c=target[pivot]/row[pivot] + return c if all(c*row[i]==x for i,x in target.items()) else None + + +def sort_key(record): + return -q(record["gross"][0]),record["bank_count"],tuple(record["clocks"]) + + +def scan(w,cases,results,span_pool): + n,m=w["public"],w["owned_fields"] + rows=[{i:Q(1)} for i in range(n)]+[{} for _ in range(m)] + charts=w["initial"]+[None]*m + bank=defaultdict(set) + for i,c in enumerate(charts[:n]): + bank[c].add(i) + source=defaultdict(list) + cuts=defaultdict(list) + for c in cases.values(): + source[c["clocks"][1]].append(c) + cuts[c["cut"]].append(c) + fresh=set() + old_rows={} + tape=w["program"] + for t in range(max(cuts)+1): + for c in source.get(t,()): + row=rows[c["peer"]] + assert row and row=={int(i):q(x) for i,x in c["target_row"].items()} + old_rows[tuple(c["clocks"])]=row + for c in cuts.get(t,()): + key=tuple(c["clocks"]) + target=old_rows.pop(key) + dst=c["role"] + chart=c["chart"] + assert charts[dst]==chart + donors=[(r,rows[r]) for r in sorted(bank[chart]-{dst})] + hit=None + missing=set(target) + for r,row in donors: + ratio=proportional(target,row) + if hit is None and ratio is not None: + hit=[r,ratio,ratio*q(tape[key[1]][3])] + missing.difference_update(row) + result={"clocks":key,"old_origin":c["old_origin"],"role":dst,"chart":chart, + "source_role":c["peer"],"cut":t,"observer":tape[t] if t=n) + bank[a].remove(d); bank[b].add(d) + charts[d]=b + elif op=="INIT": + assert d>=n and charts[d] is None and not rows[d] + charts[d]=args[0] + bank[args[0]].add(d) + fresh.add(d) + continue + elif op=="CLEAR": + assert d>=n and charts[d]==args[0] + bank[args[0]].remove(d) + charts[d],rows[d]=None,{} + elif op=="SCALE": + a,f=args + assert charts[d]==f + rows[d]={i:q(a)*v for i,v in rows[d].items()} + else: + s,a,f=args + assert op in ("ADD","COPY") and d!=s and charts[d]==charts[s]==f + assert op!="COPY" or (d>=n and d in fresh and not rows[d]) + row=rows[d].copy() + axpy(row,rows[s],q(a)) + rows[d]=row + fresh.discard(d) + assert not old_rows + + +def dot(row,x): + return sum(v*x.get(i,0) for i,v in row.items()) + + +def exact_span(target,donors): + basis={} + for role,row in donors: + w,c=row.copy(),{role:Q(1)} + for p,(b,a) in sorted(basis.items()): + if p in w: + v=-w[p] + axpy(w,b,v); axpy(c,a,v) + if w: + p=min(w) + k=w[p] + basis[p]=({i:v/k for i,v in w.items()},{i:v/k for i,v in c.items()}) + rest,c=target.copy(),{} + for p,(b,a) in sorted(basis.items()): + if p in rest: + v=rest[p] + axpy(rest,b,-v); axpy(c,a,v) + if not rest: + rows=dict(donors) + combined={} + for r,v in c.items(): + axpy(combined,rows[r],v) + assert combined==target + return {"rank":len(basis),"span":True,"coefficients":c} + j=min(rest) + x={j:Q(1)} + for p,(b,_) in sorted(basis.items(),reverse=True): + v=-dot(b,x) + if v: + x[p]=v + assert all(dot(row,x)==0 for _,row in donors) + assert dot(target,x)==rest[j]!=0 + return {"rank":len(basis),"span":False,"separator":x,"source_value":rest[j]} + + +def main(): + assert __debug__ + signal(SIGALRM,stop) + raw=decompress(read("7334-WORD.json.gz")) + assert sha256(raw).hexdigest()==PAYLOAD + w=loads(raw,object_pairs_hook=unique) + assert (w["public"],w["owned_fields"],len(w["program"]))==(1501,68,76466) + cases=freeze(w) + assert proportional({1:Q(2)},{1:Q(1)})==2 and proportional({1:Q(1)},{2:Q(1)}) is None + results,pool=[],[] + capped=False + alarm(25) + try: + scan(w,cases,results,pool) + except TimeoutError: + capped=True + finally: + alarm(0) + visited={tuple(c["clocks"]) for c in results} + assert capped or visited==set(cases) + literal=sorted((c for c in results if c["literal_donor_ratio_coefficient"]),key=sort_key) + complete_spans=[] + span_capped=False + attempted_keys=[] + if not capped and not literal: + alarm(30) + try: + for rec,target,donors in pool: + attempted_keys.append(rec["clocks"]) + proof=exact_span(target,donors) + complete_spans.append({"clocks":rec["clocks"],"proof":proof}) + if proof["span"]: + break + except TimeoutError: + span_capped=True + finally: + alarm(0) + print(dumps({"head":HEAD,"caller":CALLER,"pins":PINS,"case_cap":119,"seconds_cap":25, + "capped":capped,"results":results,"unvisited":sorted(set(cases)-visited), + "literal_survivor_count":len(literal),"literal_first_to_advance":literal[0] if literal else None, + "coordinate_survivor_count":sum(r["coordinate_missing"]==0 for r in results), + "span_case_cap":3,"span_seconds_cap":30,"span_capped":span_capped, + "span_attempted":attempted_keys,"span_complete":complete_spans}, + default=str,sort_keys=True,indent=2)) + if capped or span_capped: + raise SystemExit(2) + + +if __name__=="__main__": + main() diff --git a/research/p104-one-entrant-delayed-correction-bound/engines/independent207.py b/research/p104-one-entrant-delayed-correction-bound/engines/independent207.py new file mode 100644 index 0000000000..52770352b4 --- /dev/null +++ b/research/p104-one-entrant-delayed-correction-bound/engines/independent207.py @@ -0,0 +1,140 @@ +"""Reuse each old exact separator on the sole entrant at the moved cut.""" +from collections import defaultdict +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +from json import dumps,loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM,alarm,signal + +ROOT=Path(__file__).resolve().parent +ENGINE="247fb32afea034e934441934d117fceb57edeeecb4ae11a1b9e6e88b0d6bf420" +R206="a5ad6b1d6a0aeb376ca9b945de03f44e40fb177225133b0fdd3a6466313b2fa3" + + +def checked(path,digest): + raw=(ROOT/path).read_bytes() + assert sha256(raw).hexdigest()==digest,path + return raw + + +def old_duals(f): + out={} + for name in ("STAGE2.json","R203.json"): + for row in f["json"](name)["checked"]: + d=row["decision"] + assert d["status"]=="exact_rank_exclusion" + out[tuple(row["clocks"])]=(d["separating_covector"],d["separated_target"]) + for row in f["json"]("R204.json")["records"]: + d=row["separator"] + if d is not None: + out[tuple(row["clocks"])]=(d["input"],d["source_value"]) + assert len(out)==118 + return out + + +def probe(w,scope): + n,m=w["public"],w["owned_fields"] + values=[{} for _ in range(n+m)] + look=defaultdict(list) + for j,r in enumerate(scope): + for i,v in r["input"].items(): + assert 0<=i