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-outward-add-retiming-bound/7003-slide_stops.py b/research/p104-outward-add-retiming-bound/7003-slide_stops.py new file mode 100644 index 0000000000..16ac095ea5 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/7003-slide_stops.py @@ -0,0 +1,193 @@ +"""Find removable MOVE stops after commuting scalar contacts to another chart. + +Prepared for ToikY with substantial OpenAI Codex assistance. Apache-2.0. +""" + +from bisect import bisect_left, bisect_right +from collections import Counter, defaultdict +from hashlib import sha256 +from itertools import chain +from pathlib import Path +import gzip +import json + + +SOURCE = Path(__file__).resolve().parents[1] / "shared-wire-split-composition/data/final.json.gz" +HEAD = "93effe2a135bf57b9e484cb630d8dd057159aec9" +PAYLOAD_SHA = "91429a6b96729292a8764836e00c87a6f7cd3b76f05159033f4867f69a98d097" + + +def need(value, why): + if not value: + raise ValueError(why) + + +def payload(word): + return json.dumps(word, sort_keys=True, separators=(",", ":")).encode() + + +def span(basis): + space = {0} + for x in basis: + need(0 < x < 512 and x not in space, "Invalid binary basis") + space.update(x ^ y for y in tuple(space)) + return frozenset(space) + + +def roles(event): + return event[1:3] if event[0] in {"ADD", "COPY"} else event[1:2] + + +def commute(left, right): + """MOVE is chart transport, hence identity in normalized coordinates.""" + if right[0] == "MOVE" or not set(roles(left)).intersection(roles(right)): + return True + if left[0] == right[0] == "ADD": + return left[2] != right[1] and right[2] != left[1] + if left[0] == right[0] == "SCALE": + return True + return False + + +def inventory(word, spaces): + program = word["program"] + public = len(word["initial"]) + all_roles = public + word["owned_fields"] + history = defaultdict(list) + transitions = [[-1] for _ in range(all_roles)] + charts = [[f] for f in word["initial"]] + [[None] for _ in range(word["owned_fields"])] + for i, event in enumerate(program): + op, role = event[:2] + for touched in roles(event): + history[touched].append(i) + current = charts[role][-1] + if op == "MOVE": + a, b, private = event[2:] + need(current == a and private == (role >= public), ("MOVE frame", i)) + need(spaces[a] < spaces[b] or (private and spaces[b] < spaces[a]), ("MOVE nested", i)) + transitions[role].append(i) + charts[role].append(b) + elif op == "INIT": + need(current is None and role >= public, ("INIT", i)) + transitions[role].append(i) + charts[role].append(event[2]) + elif op == "CLEAR": + need(current == event[2] and role >= public, ("CLEAR", i)) + transitions[role].append(i) + charts[role].append(None) + elif op in {"ADD", "COPY", "SCALE"}: + need(all(charts[s][-1] == event[-1] for s in roles(event)), ("Scalar chart", i)) + else: + raise ValueError(("Unknown event", i)) + need([c[-1] for c in charts] == word["final"] + [None] * word["owned_fields"], "Final charts") + return history, transitions, charts + + +def scalar_interval(index, program, history, moved): + event = program[index] + conflicts = set(chain.from_iterable(history[r] for r in roles(event))) - moved + incompatible = [i for i in conflicts if not commute(event, program[i])] + lo = max((i + 1 for i in incompatible if i < index), default=0) + hi = min((i for i in incompatible if i > index), default=len(program)) + return lo, hi + + +def first_slot(lo, hi, role, chart, transitions, charts): + if lo > hi: + return None + for j in range(bisect_left(transitions[role], lo) - 1, bisect_left(transitions[role], hi)): + if charts[role][j] == chart: + cut = max(lo, transitions[role][j] + 1) + if cut <= hi: + return cut + return None + + +def placement(role, contacts, bounds, frame, program, trans, charts): + lo, hi = bounds + chosen = [] + for index, available_lo, available_hi in contacts: + left = max(lo, available_lo) + right = min(hi, available_hi) + event = program[index] + if event[0] == "SCALE": + cut = left if left <= right else None + else: + other = event[1] if event[2] == role else event[2] + cut = first_slot(left, right, other, frame, trans, charts) + if cut is None: + return None + lo = cut + chosen.append((index, cut, frame)) + return chosen + + +def plans(word, spaces, history, trans, charts): + program = word["program"] + stats = Counter() + hits = [] + for role, route in enumerate(trans): + for idx, (first, second) in enumerate(zip(route, route[1:])): + if first < 0 or program[first][0] != "MOVE" or program[second][0] != "MOVE": + continue + e, f = program[first], program[second] + a, b, c = e[2], e[3], f[3] + need(b == f[2], "Consecutive MOVE endpoint") + stats["two_hops"] += 1 + if not (a == c or spaces[a] < spaces[c] or (e[4] and spaces[c] < spaces[a])): + stats["unnested_shortcut"] += 1 + continue + start = bisect_right(history[role], first) + stop = bisect_left(history[role], second) + contacts = history[role][start:stop] + stats[f"eligible_{len(contacts)}_contacts"] += 1 + if any(program[i][0] not in {"ADD", "SCALE"} for i in contacts): + stats["exclusive_middle_contact"] += 1 + continue + moved = set(contacts) + contacts = [(i, *scalar_interval(i, program, history, moved)) for i in contacts] + prev_event = route[idx - 1] + next_event = route[idx + 2] if idx + 2 < len(route) else len(program) + for pivot in range(len(contacts) + 1): + left = placement(role, contacts[:pivot], (prev_event + 1, first), a, program, trans, charts) + if left is None: + continue + right = placement(role, contacts[pivot:], (second + 1, next_event), c, program, trans, charts) + if right is None: + continue + remove_ranks = [abs(len(word["frames"][a]) - len(word["frames"][b])), + abs(len(word["frames"][b]) - len(word["frames"][c]))] + replacement_rank = abs(len(word["frames"][a]) - len(word["frames"][c])) + hits.append({"role": role, "moves": [first, second], "frames": [a, b, c], + "repositioned": left + right, "old_move_ranks": remove_ranks, + "replacement_rank": replacement_rank}) + break + return stats, hits + + +def controls(): + e = ["ADD", 1, 2, "1", 0] + need(commute(e, ["ADD", 1, 3, "-1", 0]), "Shared destination commutes") + need(commute(e, ["ADD", 3, 2, "-1", 0]), "Shared source commutes") + need(not commute(e, ["ADD", 2, 3, "-1", 0]), "Source version must be preserved") + need(not commute(e, ["COPY", 4, 1, "1", 0]), "Copy barrier") + trans, charts = [[-1, 3, 6]], [[4, 7, 9]] + need(first_slot(3, 6, 0, 7, trans, charts) == 4, "Correct cut after MOVE") + need(first_slot(3, 3, 0, 7, trans, charts) is None, "Chart not reached") + return 6 + + +def main(): + count = controls() + word = json.loads(gzip.decompress(SOURCE.read_bytes())) + digest = sha256(payload(word)).hexdigest() + need(digest == PAYLOAD_SHA, "Native word differs from pinned source") + spans = [span(basis) for basis in word["frames"]] + history, trans, charts = inventory(word, spans) + stats, hits = plans(word, spans, history, trans, charts) + print(json.dumps({"head": HEAD, "source_sha256": digest, "controls": count, + "stats": dict(stats), "nominations": hits}, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-outward-add-retiming-bound/7481-APPLICATION.json b/research/p104-outward-add-retiming-bound/7481-APPLICATION.json new file mode 100644 index 0000000000..28390c8bb4 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/7481-APPLICATION.json @@ -0,0 +1,76 @@ +{ + "status": "PASS_COMPLETE_CONDITIONAL_CHANGED_PRODUCER", + "source_head": "58a9d052143f5d85295ed2d0163591c47f89a331", + "canonical_main_pin": "e54523517d0f03e58352e647c403a5af3e525a57", + "caller_head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate_canonical_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8", + "candidate_gzip_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "conditional_claim": "3647081039689/1000000000000000", + "claim_decimal": "0.003647081039689", + "comparison_claim": "729355574567/200000000000000", + "exact_claim_improvement": "151583427/500000000000000", + "directed_crossing_bracket": [ + "9117702599223995588631135479313/2500000000000000000000000000000000", + "36470810396895982354524541917253/10000000000000000000000000000000000" + ], + "native_paid_delta": { + "1": 1, + "3": -1, + "4": -1, + "6": 1 + }, + "native_productive_delta": {}, + "signed_paid_delta": { + "1": 17, + "3": -17, + "4": -17, + "6": 17 + }, + "signed_productive_delta": {}, + "paid_calls": 110519, + "productive_calls": 22461, + "surplus": 1424, + "empty_credit": 0, + "native_events": 76475, + "added_operations": { + "ADD": 3 + }, + "owned_labels": 68, + "owned_lifetimes": 74, + "owned_peak": 50, + "grid": { + "odd_scale": 1125, + "fractional_bits": 25 + }, + "ordinary_bound": 782785912, + "ordinary_increase": 1360, + "precision_coefficient": 2430, + "fixed_tape": { + "native_invocations": 17, + "monomial_map_slots": 298808, + "elementary_records_upper": 25477565312, + "scalar_services_upper": 43830720, + "context_c": 2430 + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "receipt_sha256": { + "validation_native/NATIVE-RESULT.json": "4f2024c0a84be0389a2f0469a0ea3f27af995b17fa641211c94a34807b8624f9", + "validation_signed/RESULT.json": "e5c8d8c0cf4d3f3fc60ffe70eb084cf6c9eadf8e646c74b48762501bf5367474", + "reroute/INDEPENDENT-RESULT.json": "7dba1b98b3b102c714bca9cbdea2826e74e759194dfb92026c9ca293f0fc17a2", + "reroute/ADVERSARIAL.json": "4029026fa0e7f13a70b8aca8a7dc4efcbe9347f98eb975d96c1db285683358f7" + }, + "scope": "Fresh source-aware local replay under the five retained assumptions. No maintainer selection or canonical edit is made." +} diff --git a/research/p104-outward-add-retiming-bound/7481-WORD.json.gz b/research/p104-outward-add-retiming-bound/7481-WORD.json.gz new file mode 100644 index 0000000000..77df4ad624 Binary files /dev/null and b/research/p104-outward-add-retiming-bound/7481-WORD.json.gz differ diff --git a/research/p104-outward-add-retiming-bound/NOTICE.md b/research/p104-outward-add-retiming-bound/NOTICE.md new file mode 100644 index 0000000000..fe601c0df6 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/NOTICE.md @@ -0,0 +1 @@ +Apache-2.0. #7003 supplies the exact retained commuting ADD and coframe placement scanner. #7481/#7480/#7334 supply the native construction lineage, #7113 the signed caller, and #7362/#7298 the directed tariff. #7434 covers the distinct incoming-ADD historical-bank scope. OpenAI Codex and subagents materially assisted implementation, independent verification and packaging. diff --git a/research/p104-outward-add-retiming-bound/PINS.json b/research/p104-outward-add-retiming-bound/PINS.json new file mode 100644 index 0000000000..7c8c3c9377 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/PINS.json @@ -0,0 +1,11 @@ +{ + "7003-slide_stops.py": "64a69bcd5689e17a081187a17ef2913adece970da653afa606b47cf130f1aa04", + "7481-APPLICATION.json": "1d93fae969ff24ecb91bb4bee6af74daaa9ea99141bcf630a77eeb1a167b1799", + "7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "PROVENANCE.json": "432cd8aabefb36fe94c8959af6bb76944eb62257a48c4f2df099aaf706021a41", + "check_outward_contact.py": "db17197ca407d1092102f40eb90957a609caa3749a8e65635e99810f069d9fba", + "independent_outward.py": "2f03eb7d18c8939f733f14d029a05d6159f4e29699bf3437ef2f5af7f6aa9c07", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", + "receipts/INDEPENDENT.json": "37c8e502efe8aac07dbfe385448d54295b90161242261865bf11cfcbf07cb0ad", + "receipts/PRIMARY.jsonl.gz": "e94d357a56ba6e350a5f2d6466fb0f7517e91cbb98c60455c84e77a76fd0c84f" +} diff --git a/research/p104-outward-add-retiming-bound/PROOF.md b/research/p104-outward-add-retiming-bound/PROOF.md new file mode 100644 index 0000000000..04dcb38dde --- /dev/null +++ b/research/p104-outward-add-retiming-bound/PROOF.md @@ -0,0 +1,9 @@ +# One outward scalar contact between two fixed MOVEs + +Pin the exact #7481 native word and retain its #7113 signed caller. Enumerate all consecutive MOVEs on each public role. The source word has strict ascending chart inclusions for public MOVEs. Select only chains with exactly one contact on the moving role strictly between the two MOVEs. Require that contact to be an ADD which reads that role and writes another role. + +In chart-normalized coordinates a MOVE is the identity. An ADD of coefficient a from s to d acts as `I+a E_ds`. Two ADDs sharing an operand commute precisely in the structural class used here, where neither ADD writes the other's source. A scalar on disjoint operands also commutes. Treat any other overlapping scalar as a barrier and keep every peer chart interval and every barrier order fixed. A relocated ADD may be inserted only after the last prior barrier and before the first subsequent barrier. The moving role must be in its old source chart before its first MOVE, or in its old final chart after its second MOVE and before the next route event. The peer must be on the corresponding endpoint chart at the same cut. This specifies the tested class even when a special algebraic coincidence might allow more relocation. + +The primary uses the exact #7003 contact-slide routines to compute legal cut intervals and placement. The independent engine validates live frames across the literal tape, then separately constructs public MOVE intervals, all peer chart intervals and both operand-contact sequences. It intersects those intervals and checks the closest noncommuting barrier on either side. The engines agree on every exact key `(role,first MOVE,second MOVE,ADD)`, the paid ranks and the absence of both earlier and later placements. There are 958 cases and no unresolved placements within this model. + +If a placement existed, combining the two old increasing transitions of ranks a and b into one would save `17(H(a)+H(b)−H(a+b))` in the retained caller before corrections, with `H(r)=r^(1−κ)`. The primary receipt records the directed interval for each quote. With zero legal relocations, no paid or productive histogram changes are realized. This result does not need or supply a new literal native construction. diff --git a/research/p104-outward-add-retiming-bound/PROVENANCE.json b/research/p104-outward-add-retiming-bound/PROVENANCE.json new file mode 100644 index 0000000000..2fa83d33fc --- /dev/null +++ b/research/p104-outward-add-retiming-bound/PROVENANCE.json @@ -0,0 +1,8 @@ +{ + "ai_assistance": "OpenAI Codex and subagents materially assisted implementation, independent verification and packaging.", + "caller": {"head":"07a76c5e2738882c0cb322278e56f6cae3c9885d","pr":7113}, + "comparator": {"head":"89eaa9d8cae37c1540de98f2d29a3abaabb96a2b","tree":"984434b58abc2d69c3cf45609a755be566c6ac91","pr":7481,"kappa":"0.003647081039689","package":"research/p104-funded-485-1455-return","word":"producer54/reroute/WORD.json.gz","application":"producer54/APPLICATION.json"}, + "scanner": {"head":"ec30476096b2f9aed718152a2fa3712d1c4e884d","pr":7003,"path":"research/shared-wire-stop-fusion/slide_stops.py"}, + "credits": {"7003":"Exact source-version and common-chart placement scanner.","7113":"Retained signed 17-stage caller.","7362":"Directed rank-power arithmetic.","7434":"Related incoming-ADD scope at historical receivers.","7481":"Exact benchmark word and complete directed crossing."}, + "schema_version": 1 +} diff --git a/research/p104-outward-add-retiming-bound/README.md b/research/p104-outward-add-retiming-bound/README.md new file mode 100644 index 0000000000..17cb28d638 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/README.md @@ -0,0 +1,15 @@ +# Bound fixed-route outward ADD retiming + +**NO VERIFIED GAIN.** On exact #7481, no public two-MOVE chain with exactly one middle-chart contact can remove that stop by relocating its outward ADD to an endpoint when the peer's chart itinerary and noncommuting source chronology are fixed. Two implementations agree on all 958 routes, with zero earlier or later placements. This applies to the stated relocation class on the exact literal word. [#7481](https://github.com/CrocSwap/integer-mult-bounds/pull/7481) + +From a clean POSIX checkout with CPython 3.12 and assertions enabled: + +```sh +python3.12 -I -B research/p104-outward-add-retiming-bound/replay.py +``` + +[Scope and proof](PROOF.md) · [Verification](VERIFICATION.md) · [Source pins and credit](PROVENANCE.json) + +## Open next questions + +A peer with a movable paid chart arrival can change the coframe interval. Before searching more sites, name a concrete route, pin its two new arrival windows, and check both operand source versions and all outward results. A literal candidate must retain the exact signed action and pass a fully charged price. Joint peer retiming, multiple middle contacts, changed scalar dependencies and newly encoded donor histories are outside this screen. diff --git a/research/p104-outward-add-retiming-bound/SOURCES.json b/research/p104-outward-add-retiming-bound/SOURCES.json new file mode 100644 index 0000000000..e8c2f265cd --- /dev/null +++ b/research/p104-outward-add-retiming-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-outward-add-retiming-bound/TASK.json b/research/p104-outward-add-retiming-bound/TASK.json new file mode 100644 index 0000000000..28763884df --- /dev/null +++ b/research/p104-outward-add-retiming-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "actual_scope": "Exact #7481 public consecutive MOVEs with exactly one outward middle-chart ADD. Fixed peer charts and scalar source chronology. Complete 958-case population.", + "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent replay and packaging.", + "author": "P104 outward ADD retiming audit", + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "bottleneck_link": "A legal relocated outward ADD would allow two nested paid moves to fuse with fixed productive ranks and a strictly positive gross signed margin.", + "budget_minutes": 10, + "evidence": "Exact contact-slide scanner and independently indexed chronology agree on all 958 case identities and both placement decisions. No placement survives.", + "open_questions": [ + { + "blocked_by": "Every fixed-peer earlier and later endpoint placement was excluded.", + "first_step": "Pin one named pair of changed arrival windows and verify both operand source versions and full outputs.", + "question": "Can one additional existing paid peer route be legally retimed?", + "why_it_matters": "An expanded coframe window may permit a positive-cost MOVE fusion." + } + ], + "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": "Test coframe and source-version commuting relocation of a single outward ADD, keeping literal old peer routes rather than solving a receiver-span problem.", + "scope_status": "changed", + "stop_rule": "One exact 958-case population, 30 seconds per engine, no new route or partial-case inference after a timeout.", + "task_id": "p104-side-correction" +} diff --git a/research/p104-outward-add-retiming-bound/VERIFICATION.md b/research/p104-outward-add-retiming-bound/VERIFICATION.md new file mode 100644 index 0000000000..40853c4f23 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/VERIFICATION.md @@ -0,0 +1,5 @@ +# Verification + +The original primary printed all 958 cases and its completion marker. Its measured elapsed time was 76.82 seconds, with 0.43 seconds user and 0.03 seconds system, exceeding the declared 30-second wall limit despite an in-process alarm. The timing does not identify why. The independently written chart interval and ADD barrier replay completed in 0.22 seconds, exit zero, under both its own 30-second deadline and a parent 30-second process cap. It verified the complete scope within the declared budget. The paired receipts are preserved unchanged in mathematical content. The primary receipt is bundled with deterministic gzip compression and is compared by decompressed bytes. + +The clean replay authenticates all path-keyed input hashes, runs both exact engines with individual 30-second process caps, and requires exact equality to both frozen receipts. A changed source byte, a duplicate pin key and a modified claimed result are rejected. The package does not rerun the full #7481 supplier or test alternative physical itineraries. diff --git a/research/p104-outward-add-retiming-bound/VERIFY.json b/research/p104-outward-add-retiming-bound/VERIFY.json new file mode 100644 index 0000000000..b57add9f11 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/VERIFY.json @@ -0,0 +1,8 @@ +{ + "commands": [{"argv":["{python}","-I","-B","{package}/replay.py"],"checks":"Authenticate exact sources and replay all 958 fixed-route outward ADD decisions with two engines.","timeout_seconds":70}], + "inputs": [], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/p104-outward-add-retiming-bound/check_outward_contact.py b/research/p104-outward-add-retiming-bound/check_outward_contact.py new file mode 100644 index 0000000000..1421314539 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/check_outward_contact.py @@ -0,0 +1,101 @@ +"""Bound a fixed two-MOVE fusion by relocating one outward ADD on exact #7481.""" + +from argparse import ArgumentParser +from bisect import bisect_left, bisect_right +from fractions import Fraction +from gzip import decompress +from hashlib import sha256 +from json import dumps, loads +from pathlib import Path +from runpy import run_path +from signal import SIGALRM, alarm, signal + +HERE = Path(__file__).resolve().parent +CAP = 30 +PINS = { + "7003-slide_stops.py": "64a69bcd5689e17a081187a17ef2913adece970da653afa606b47cf130f1aa04", + "7481-WORD.json.gz": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9", + "7481-APPLICATION.json": "1d93fae969ff24ecb91bb4bee6af74daaa9ea99141bcf630a77eeb1a167b1799", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} + + +def emit(record): + print(dumps(record, sort_keys=True, default=str), flush=True) + + +def expired(_signal, _frame): + emit({"status": "UNRESOLVED_TIMEOUT"}) + raise SystemExit(124) + + +def authenticate(path): + raw = path.read_bytes() + if sha256(raw).hexdigest() != PINS[path.name]: + raise ValueError(f"Hash mismatch for {path.name}") + return raw + + +def main(): + parser = ArgumentParser(description=__doc__) + parser.add_argument("--input-root", required=True, type=Path) + parser.add_argument("--preflight", action="store_true") + args = parser.parse_args() + signal(SIGALRM, expired) + alarm(CAP) + script = HERE / "7003-slide_stops.py" + authenticate(script) + inputs = args.input_root.resolve() + packed_word = authenticate(inputs / "7481-WORD.json.gz") + application = authenticate(inputs / "7481-APPLICATION.json") + price_script = inputs / "pricing.py" + authenticate(price_script) + old = run_path(str(script)) + controls = old["controls"]() + if args.preflight: + emit({"status": "PREFLIGHT_PASSED", "inputs": sorted(PINS), "controls": controls}) + return + + word = loads(decompress(packed_word)) + tape = word["program"] + frames = word["frames"] + spaces = [old["span"](frame) for frame in frames] + history, routes, charts = old["inventory"](word, spaces) + lo, hi = map(Fraction, loads(application)["directed_crossing_bracket"]) + bound = run_path(str(price_script))["power_bounds"] + tested = 0 + + for role, route in enumerate(routes[:word["public"]]): + for index, (first, second) in enumerate(zip(route, route[1:])): + if first < 0 or tape[first][0] != "MOVE" or tape[second][0] != "MOVE": + continue + clocks = history[role] + contacts = clocks[bisect_right(clocks, first):bisect_left(clocks, second)] + if len(contacts) != 1: + continue + contact, = contacts + event = tape[contact] + if event[0] != "ADD" or event[2] != role: + continue + a, b, c = tape[first][2], tape[first][3], tape[second][3] + r1, r2 = len(frames[b]) - len(frames[a]), len(frames[c]) - len(frames[b]) + assert r1 > 0 and r2 > 0 and spaces[a] < spaces[b] < spaces[c] + lower = 17 * (bound(r1, hi)[0] + bound(r2, hi)[0] - bound(r1+r2, lo)[1]) + upper = 17 * (bound(r1, lo)[1] + bound(r2, lo)[1] - bound(r1+r2, hi)[0]) + left, right = old["scalar_interval"](contact, tape, history, {contact}) + next_move = route[index + 2] if index + 2 < len(route) else len(tape) + row = [(contact, left, right)] + earlier = old["placement"](role, row, (route[index - 1]+1, first), a, tape, routes, charts) + later = old["placement"](role, row, (second+1, next_move), c, tape, routes, charts) + tested += 1 + emit({"role": role, "moves": [first, second], "contact": contact, + "ranks": [r1, r2], "optimistic_raw": [lower, upper], + "earlier": earlier, "later": later}) + if lower > 0 and (earlier or later): + emit({"status": "NEEDS_LITERAL_SPLICE_AND_INVOICE", "tested": tested}) + return + emit({"status": "SCOPED_EXHAUSTION", "tested": tested}) + + +if __name__ == "__main__": + main() diff --git a/research/p104-outward-add-retiming-bound/independent_outward.py b/research/p104-outward-add-retiming-bound/independent_outward.py new file mode 100644 index 0000000000..d00efb8f99 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/independent_outward.py @@ -0,0 +1,128 @@ +"""Independently verify fixed-peer outward contacts on exact #7481.""" +from bisect import bisect_left, bisect_right +from collections import defaultdict +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 exit +from time import monotonic + +ROOT = Path(__file__).resolve().parent +PACKED = 'acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9' +PAYLOAD = '64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8' +CAP = 30 + + +def inputs(event): + return event[1:3] if event[0] in ('ADD', 'COPY') else event[1:2] + + +def overlap_barrier(add, other): + dst, src = add[1:3] + if other[0] == 'MOVE' or not (dst in inputs(other) or src in inputs(other)): + return False + if other[0] != 'ADD': + return True + return other[1] == src or other[2] == dst + + +def index(tape, initial, owned): + active = list(initial) + [None] * owned + visits = [[(-1, c)] for c in active] + contacts = defaultdict(list) + for t, event in enumerate(tape): + for role in inputs(event): + contacts[role].append(t) + op, role, *args = event + if op == 'MOVE': + assert active[role] == args[0] and args[2] == (role >= len(initial)) + active[role] = args[1] + elif op == 'INIT': + assert active[role] is None and role >= len(initial) + active[role] = args[0] + elif op == 'CLEAR': + assert active[role] == args[0] and role >= len(initial) + active[role] = None + else: + assert all(active[j] == event[-1] for j in inputs(event)) + continue + visits[role].append((t, active[role])) + return visits, contacts, active + + +def select_slot(visits, chart, left, right, tape_end): + if left > right: + return None + for i, (event, current) in enumerate(visits): + if current != chart: + continue + next_event = visits[i+1][0] if i+1 < len(visits) else tape_end + earliest = max(left, event+1) + if earliest <= min(right, next_event): + return earliest + return None + + +def main(): + assert __debug__ + started = monotonic() + tested = [] + def timeout(signum, frame): + print(dumps({'status':'unresolved_timeout','checked':len(tested),'cap_seconds':CAP})) + exit(124) + signal(SIGALRM, timeout) + alarm(CAP) + packed = (ROOT / '7481-WORD.json.gz').read_bytes() + assert sha256(packed).hexdigest() == PACKED + raw = decompress(packed) + assert sha256(raw).hexdigest() == PAYLOAD + word = loads(raw) + tape = word['program'] + frames = word['frames'] + public = word['public'] + visits, contacts, final = index(tape, word['initial'], word['owned_fields']) + assert final == word['final'] + [None] * word['owned_fields'] + for role in range(public): + route = visits[role] + for i in range(1, len(route)-1): + start, mid = route[i-1][1], route[i][1] + first, second = route[i][0], route[i+1][0] + end = route[i+1][1] + points = contacts[role] + between = points[bisect_right(points,first):bisect_left(points,second)] + if len(between) != 1: + continue + clock, = between + add = tape[clock] + if add[0] != 'ADD' or add[2] != role: + continue + peer = add[1] + candidates = sorted(set(contacts[peer]).union(points)-{clock}) + k = bisect_left(candidates,clock) + left = next((t+1 for t in reversed(candidates[:k]) if overlap_barrier(add,tape[t])),0) + right = next((t for t in candidates[k:] if overlap_barrier(add,tape[t])),len(tape)) + before = select_slot(visits[peer],start,max(left,route[i-1][0]+1),min(right,first),len(tape)) + final_cut = route[i+2][0] if i+2 < len(route) else len(tape) + after = select_slot(visits[peer],end,max(left,second+1),min(right,final_cut),len(tape)) + r1,r2 = len(frames[mid])-len(frames[start]),len(frames[end])-len(frames[mid]) + assert r1 > 0 and r2 > 0 + tested.append({'role':role,'moves':[first,second],'contact':clock,'ranks':[r1,r2], + 'earlier':None if before is None else [[clock,before,start]], + 'later':None if after is None else [[clock,after,end]]}) + primary = [loads(row) for row in decompress((ROOT / 'receipts/PRIMARY.jsonl.gz').read_bytes()).splitlines()] + assert primary[-1] == {'status':'SCOPED_EXHAUSTION','tested':958} + assert len(tested) == len(primary)-1 == 958 + for actual, expected in zip(tested, primary): + assert actual == {key:expected[key] for key in actual}, (actual,expected) + assert not any(x['earlier'] or x['later'] for x in tested) + assert monotonic()-started < CAP + alarm(0) + print(dumps({'status':'PASS_INDEPENDENT_OUTWARD_EXHAUSTION','cases':len(tested), + 'cap_seconds':CAP,'unresolved':0,'survivors':0,'all_case_ids_agree':True, + 'word_sha256':PACKED,'payload_sha256':PAYLOAD},sort_keys=True,indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/p104-outward-add-retiming-bound/pricing.py b/research/p104-outward-add-retiming-bound/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/pricing.py @@ -0,0 +1,82 @@ +"""Directed interval arithmetic and the retained signed BIT invoice.""" +from collections import Counter +from fractions import Fraction +from functools import cache + +TARGET = "10018846261809/2500000000000000" +SCALE = 10**49 + + +def rounded(x, upper): + scaled = SCALE*x + if upper: + return Fraction(-((-scaled.numerator) // scaled.denominator), SCALE) + return Fraction(scaled.numerator // scaled.denominator, SCALE) + + +@cache +def log_bounds(x): + z = (x-1)/(x+1) + terms = 60 + exact_partial = 2*sum(z**(2*i+1)/(2*i+1) for i in range(terms)) + tail = 2*z**(2*terms+1)/((2*terms+1)*(1-z*z)) + return rounded(exact_partial, False), rounded(exact_partial+tail, True) + + +@cache +def power_bounds(rank, k): + binary = 2**(rank.bit_length()-1) + shift = binary.bit_length()-1 + l2, u2 = log_bounds(Fraction(2)) + lo, hi = log_bounds(Fraction(rank, binary)) + lo, hi = k*(lo+shift*l2), k*(hi+shift*u2) + assert 0 <= lo <= hi < 1 + + def exponential(z, terms): + total = term = Fraction(1) + for i in range(1, terms+1): + term *= -z/i + total += term + return total + + return rounded(rank*exponential(hi, 35), False), rounded(rank*exponential(lo, 34), True) + + +def cost(hist, k): + lower = upper = Fraction(0) + for r, n in hist.items(): + a, b = (n*x for x in power_bounds(r, k)) + lower += min(a, b) + upper += max(a, b) + return lower, upper + + +def profile(invoice, native, word, ranks): + copies = invoice["native_calls"] + assert copies == len(invoice["native_instances"]) == 36 + assert {tuple((r["stage"], r["copy"])) for r in invoice["native_instances"]} == { + (stage, which) for stage in range(1, 19) for which in (0, 1) + } + assert all(r["ports"] == 111 for r in invoice["native_instances"]) + assert native == Counter({int(r): n for r, n in invoice["native_paid"].items()}) + assert sum(native.values()) == 2871 + caller_paid = {1: 444, **{r: 444 for r in range(7, 57, 7)}} + assert invoice["event_counts"]["QUERY"]*111 == caller_paid[1] + assert invoice["event_counts"]["IDLE_ONE"]*111 == 8*444 + full_paid = Counter({r: copies*n for r, n in native.items()}) + full_paid.update(caller_paid) + + helpers = Counter(ranks[word["final"][j]]-ranks[word["start"][j]] + for j in range(222, word["public"])) + assert helpers == Counter({int(r): n for r, n in invoice["native_helpers"].items()}) + caller_targets = {**{r: 444 for r in range(8, 65, 7)}, 127: 222} + full_targets = Counter({r: copies*n for r, n in helpers.items()}) + full_targets.update(caller_targets) + assert full_paid == Counter({int(r): n for r, n in invoice["paid"].items()}) + assert full_targets == Counter({int(r): n for r, n in invoice["targets"].items()}) + assert sum(full_paid.values()) == invoice["paid_jobs"] + assert sum(full_targets.values()) == invoice["productive_fields"] + signed = full_targets.copy() + signed.subtract(full_paid) + assert sum(r*n for r, n in signed.items()) == invoice["rank_surplus"] + return signed, copies diff --git a/research/p104-outward-add-retiming-bound/receipts/INDEPENDENT.json b/research/p104-outward-add-retiming-bound/receipts/INDEPENDENT.json new file mode 100644 index 0000000000..838db081e2 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/receipts/INDEPENDENT.json @@ -0,0 +1,10 @@ +{ + "all_case_ids_agree": true, + "cap_seconds": 30, + "cases": 958, + "payload_sha256": "64fca675b91298868e12f09423b47e0c2327cba7095e35c8919c1953b4ed68b8", + "status": "PASS_INDEPENDENT_OUTWARD_EXHAUSTION", + "survivors": 0, + "unresolved": 0, + "word_sha256": "acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9" +} diff --git a/research/p104-outward-add-retiming-bound/receipts/PRIMARY.jsonl.gz b/research/p104-outward-add-retiming-bound/receipts/PRIMARY.jsonl.gz new file mode 100644 index 0000000000..84ab258572 Binary files /dev/null and b/research/p104-outward-add-retiming-bound/receipts/PRIMARY.jsonl.gz differ diff --git a/research/p104-outward-add-retiming-bound/replay.py b/research/p104-outward-add-retiming-bound/replay.py new file mode 100644 index 0000000000..84a4eecdb3 --- /dev/null +++ b/research/p104-outward-add-retiming-bound/replay.py @@ -0,0 +1,84 @@ +"""Run both exact outward ADD engines with independent process limits.""" +from gzip import decompress +from hashlib import sha256 +from json import loads +from os import killpg +from pathlib import Path +from signal import SIGKILL +from subprocess import PIPE, Popen, TimeoutExpired +from sys import executable, implementation, version_info + +ROOT = Path(__file__).resolve().parent +FILES = {'7481-WORD.json.gz','7481-APPLICATION.json','7003-slide_stops.py','pricing.py', + 'check_outward_contact.py','independent_outward.py','PROVENANCE.json', + 'receipts/PRIMARY.jsonl.gz','receipts/INDEPENDENT.json'} + + +def unique(pairs): + result = dict(pairs) + assert len(result) == len(pairs), 'duplicate JSON key' + return result + + +def parse(raw): + return loads(raw, object_pairs_hook=unique) + + +def authenticate(raw, digest): + assert sha256(raw).hexdigest() == digest, 'changed bytes' + + +def exact_run(*args): + process = Popen([executable,'-I','-B',*map(str,args)], cwd=ROOT, + stdout=PIPE, stderr=PIPE, start_new_session=True) + try: + output, errors = process.communicate(timeout=30) + except TimeoutExpired: + killpg(process.pid, SIGKILL) + process.communicate() + raise AssertionError('unresolved process cap') from None + assert process.returncode == 0 and not errors, errors.decode(errors='replace') + return output + + +def compare(primary, independent): + assert len(primary) == 959 + assert primary[-1] == {'status':'SCOPED_EXHAUSTION','tested':958} + keys = {(row['role'],*row['moves'],row['contact']) for row in primary[:-1]} + assert len(keys) == 958 + assert all(row['earlier'] is None and row['later'] is None for row in primary[:-1]) + assert independent['cases'] == 958 and independent['cap_seconds'] == 30 + assert independent['unresolved'] == independent['survivors'] == 0 + assert independent['all_case_ids_agree'] is True + + +def must_reject(action): + try: + action() + except AssertionError: + return + raise AssertionError('mutation passed') + + +def main(): + assert __debug__ and implementation.name == 'cpython' and version_info[:2] == (3,12) + pins = parse((ROOT/'PINS.json').read_bytes()) + assert set(pins) == FILES + files = {name:(ROOT/name).read_bytes() for name in sorted(FILES)} + for name, raw in files.items(): + authenticate(raw, pins[name]) + primary = exact_run(ROOT/'check_outward_contact.py','--input-root',ROOT) + assert primary == decompress(files['receipts/PRIMARY.jsonl.gz']) + independent = parse(exact_run(ROOT/'independent_outward.py')) + assert independent == parse(files['receipts/INDEPENDENT.json']) + rows = [parse(row) for row in primary.splitlines()] + compare(rows, independent) + raw = files['7481-WORD.json.gz'] + must_reject(lambda: authenticate(bytes([raw[0]^1])+raw[1:],pins['7481-WORD.json.gz'])) + must_reject(lambda: parse('{"word":1,"word":2}')) + must_reject(lambda: compare(rows,dict(independent,survivors=1))) + print('PASS_FIXED_ROUTE_OUTWARD_ADD: 958 cases, zero placements') + + +if __name__ == '__main__': + main()