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/two-pass-width-obstruction/PROOF.md b/research/two-pass-width-obstruction/PROOF.md new file mode 100644 index 0000000000..0db9da4ba1 --- /dev/null +++ b/research/two-pass-width-obstruction/PROOF.md @@ -0,0 +1,136 @@ +# A minimum-order failure of the width-product test + +This contribution was produced by Nick Petalas. Apache-2.0. + +## Model and exact statement + +Records are distinct, initially ordered 0,...,n-1. A stable two-lane pass +assigns each record to one of two lanes and produces any interleaving of +the resulting streams that preserves each lane's incoming order. Empty +lanes are allowed. Records cannot be copied, deleted or modified. Routing +descriptions are unrestricted; this model charges passes only. + +For a target record order p, let w(p) be its longest decreasing-subsequence +length. The following claims have different evidence: + +1. The ten-record order p=(3,2,1,6,5,4,9,8,7,0) has w(p)=4 and needs + exactly three stable two-lane passes. The arguments below are written + combinatorial proofs; two separate finite exclusion engines corroborate + the lower bound. +2. No order of at most nine records with w<=4 needs more than two passes. + This is an exhaustive finite certificate at n=9, followed by restriction + of its routes. Thus ten is the minimum possible order of an obstruction + to sufficiency of the two-pass width-product bound four. + +The universal width-product necessity and its general failure of +sufficiency are prior work. In particular Mark Karpilovskij, +[Composability of Permutation Classes, Theorem 15 and Question 16](https://www.combinatorics.org/ojs/index.php/eljc/article/view/v26i1p41), +Electronic Journal of Combinatorics 26(1), P1.41, 2019, already states +I_k I_l is strictly smaller than I_(kl), where I_k is the class of +permutations partitionable into k increasing subsequences. That known +noninclusion is not claimed as new. The new repository result is this +explicit minimum-order certificate and routing obstruction. No historical +priority claim is made for the example or elementary methods. + +## One-pass alphabet + +A record order can be produced in one pass if and only if w<=2. +Necessity follows because a decreasing triple cannot share two stable +lanes. For sufficiency, assign each entry its longest decreasing-subsequence +length ending there. If an inverted pair had the same depth, appending +the second entry to a decreasing subsequence ending at the first would +increase its depth. Each of the at most two depth classes is therefore +in increasing record order and is a legal incoming lane stream. + +If the first pass outputs record order a and the second uses the sequence +b of indices into that order, the final record order is a[b[i]]. Both a +and b must avoid a decreasing triple. Conversely any such pair supplies +two legal passes. This fixes the composition convention used by the checker. + +## A forced four-cycle rules out two passes + +Suppose a two-pass route exists for the displayed p. Give each record +its ordered pair of lane choices. Two records with the same pair retain +their initial relative order through both passes. Relabel the lanes of +each pass so that record 0 has pair 00. Every other record finishes before +0, although it starts after 0. Consequently none can have pair 00. + +Each of the blocks {1,2,3}, {4,5,6} and {7,8,9} is reversed in p. +Its three records must have distinct pairs. They therefore use exactly +01,10,11, once each. Choose A with pair 01 in the first block, C with +pair 11 in the second block, and B with pair 10 in the third block. +Write <_M for the total order after the first pass. + +- Record 0 and A share first lane 0. Their initial order forces 0 <_M A. +- A and C share second lane 1. Their final block order forces A <_M C. +- C and B share first lane 1. Their initial block order forces C <_M B. +- B and 0 share second lane 0. Their final order forces B <_M 0. + +This is the impossible cycle 0 <_M A <_M C <_M B <_M 0. +It covers every lane assignment and every intermediate merge, including +empty lanes and choices dependent on the complete layout. No search +assumption or restriction on merge positions enters the argument. + +The width is exactly four. A decreasing subsequence before the terminal +0 stays inside one of the three value-separated blocks, so it has at most +three records. Appending 0 permits four, for example 3,2,1,0. + +## Three passes attain the endpoint + +The following complete orders and lane-1 record sets describe the route. +The other lane contains every remaining record. + +| Pass | Output record order | Lane-1 records | +|---|---|---| +| 1 | 1,2,3,4,5,6,7,8,9,0 | 0 | +| 2 | 2,1,3,5,4,6,8,7,9,0 | 2,5,8 | +| 3 | 3,2,1,6,5,4,9,8,7,0 | 3,6,9 | + +For each row, both lane subsequences in the preceding order are identical +to those in the output. Hence every pass is legal. All record payloads +are transported intact. The lower bound makes this three-pass route optimal. + +## Finite certificate that smaller obstructions do not exist + +The checker generates the complete one-pass alphabet at order nine by +inserting the largest record into every smaller generated permutation. +A new decreasing triple must begin with that largest record. It exists +exactly when the suffix following the insertion contains a decreasing +pair. Thus the insertion is permitted precisely when that suffix is +increasing. Removing the largest record gives a unique predecessor, so +induction proves completeness and absence of duplicates. + +A separately implemented scan of all 9!=362,880 permutations tests every +literal triple. Its one-pass set agrees exactly with the 4,862 generated +factors. The checker composes all 4,862^2=23,639,044 ordered factor pairs +and retains their complete set of final orders. Independently, a quadratic +longest-decreasing-subsequence dynamic program scans all 362,880 orders +and retains those of width at most four. The two sets are exactly equal, +with 261,808 elements. This set equality is the finite minimum-order +certificate; the count alone would not establish coverage. + +For an order on n<9 records, append the remaining larger records in +increasing order. Its width stays at most four. The nine-record certificate +provides a two-pass route for this extension. Remove the appended records +from the initial, intermediate and final orders and from both lane streams. +Restriction preserves their relative orders, giving two passes on the +original records. Hence no smaller order is an obstruction. This argument +does not construct a uniform all-size routing controller from a width test. + +As a second exclusion engine, every one of the 16,796 complete one-pass +factors a at order ten is tested. The unique possible second factor is +b=a^-1 p, and its decreasing width is always greater than two. This +corroborates the four-cycle proof without depending on the lane-type +argument. The verifier also visits all 4^9 normalized two-pass lane +assignments for p. Exactly 216 survive the necessary inverted-pair test; +every survivor has the displayed four-cycle, and an independently built +order graph is cyclic in every case. + +## Scope + +This is a finite routing certificate and a scoped combinatorial proof. +It supplies no physical stream controller, tape/head cost, workspace or +reversible cleanup implementation. More lanes, additional passes, record +copies, random access, a different routing model or a changed layout can +escape this obstruction. It is not an unconditional multitape lower bound, +a native supplier, an improved kappa, or a complete multiplication theorem. diff --git a/research/two-pass-width-obstruction/README.md b/research/two-pass-width-obstruction/README.md new file mode 100644 index 0000000000..d948bcdea7 --- /dev/null +++ b/research/two-pass-width-obstruction/README.md @@ -0,0 +1,140 @@ +# Smallest failure of the two-pass width budget + +This contribution was produced by Nick Petalas. Apache-2.0. + +Claim type: finite certificate with a scoped combinatorial proof. The layout + +```text +3,2,1,6,5,4,9,8,7,0 +``` + +has decreasing-subsequence width four but requires exactly **three** stable +two-lane passes. A forced four-cycle excludes every possible two-pass +intermediate order. Three explicit passes attain the endpoint. Every layout +of at most nine records with width at most four does admit two passes, so +ten records is the minimum size of a failure of the width-product test. + +A pass assigns each intact record to one of two order-preserving streams, +then merges them in any stable interleaving. Empty lanes and arbitrary +routing choices are allowed. No payload copies, deletions, extra lanes or +random access are supplied. This is an abstract pass count, with no physical +unit-time assertion about streams or tapes. + +[PROOF.md](PROOF.md) gives the four-cycle argument and the exact finite +minimum-order reduction. It also gives the full attaining route: + +```text +0 1 2 3 4 5 6 7 8 9 +1 2 3 4 5 6 7 8 9 0 +2 1 3 5 4 6 8 7 9 0 +3 2 1 6 5 4 9 8 7 0 +``` + +## Reproduction and evidence + +From the repository root, using CPython 3.12 and its standard library: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/two-pass-width-obstruction/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/two-pass-width-obstruction/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/two-pass-width-obstruction +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/two-pass-width-obstruction --check-source-history +``` + +Another CPython 3.12 path can replace the displayed interpreter. The direct +marker is `PASS_TWO_PASS_WIDTH_OBSTRUCTION`; the runner returns +`PASS_REGISTERED_RESEARCH_PACKAGE`. The verifier writes no files. Its stdout +receipt is generated from the actual calculations and hashes all six package +files. Normal and optimized executions perform the same checks. + +The minimum-order certificate compares complete sets, not only counts. +It enumerates all 362,880 permutations of nine records, independently +identifies the 4,862 one-pass factors, composes all 23,639,044 ordered pairs, +and obtains exactly the 261,808 width-at-most-four layouts. Restriction of +those routes settles every smaller size. All ten single-record deletions +of the new obstruction also lie in that complete two-pass set. + +Two different exclusion checks corroborate the written proof. Every one +of the 16,796 ten-record first factors has a unique residual second factor +of width greater than two. Separately, all 262,144 lane assignments normalized +at record 0 are considered; exactly 216 pass the necessary inverted-pair +condition. Each has the forced cycle, and an independently built directed +order graph is cyclic. The actual lane streams of all three upper-bound +passes are checked. Six malformed or unstable route controls reject, and +four-record reversal provides a width-four layout that does fit two passes. + +## Credit and scope + +Matarener's [#3825](https://github.com/CrocSwap/integer-mult-bounds/pull/3825) +supplies the abstract stable-lane pass obstruction in the bit-free complex +supplier context. James Reed / jwr404's +[#3839](https://github.com/CrocSwap/integer-mult-bounds/pull/3839) supplies the +earlier finite forward-composition evidence through seven records. Their +results are cited premises and context; their scientific code and counts +are not replayed as the deliverable. Retain their Walsh, native, adapter, +coverage and supplier predecessor credit. + +Mark Karpilovskij's published +[Composability of Permutation Classes](https://www.combinatorics.org/ojs/index.php/eljc/article/view/v26i1p41), +Theorem 15 and Question 16, already establishes the general failure of +sufficiency of the product-width bound. That broad noninclusion is prior +work. The explicit smallest-order certificate, four-cycle proof in this +routing contract, and standalone checker are the new repository contribution. +No historical priority claim is made for the example or standard methods. +Nick Petalas's older reversal and Gray-layout packages are related background; +their constructions, formulas and scientific code are not used as the main step. + +The `bit-new-register-model` card changes scope to this local layout side +result. Its register-algebra and supplier acceptance gate is not met here. +The source-binding first example passed at canonical base +`e54523517d0f03e58352e647c403a5af3e525a57`, priority revision 8, selected #7000. +The catalogue's assessed selection context is historical. The selected +frontier and its five assumptions are unchanged. The +[advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19541783) +records the bounded question. Live open/account PRs, recent claims, active +Discussions, local reservations, cached overlap, main README searches and +merged searches were checked. The cache covered 545 open PRs and 7,200 +Discussion records, but only 218 of 10,178 main note paths. Main-tree searches +supplement that sparse coverage; unpublished work and arbitrary diffs remain +outside it. Search absence is not a novelty certificate. + +Minimum order is established by a finite exhaustive computation. The +four-cycle exclusion and route correctness are written proofs, not formal +proof-kernel results. Independent human and formal proof-kernel review are +unclaimed. A complete forbidden-pattern basis, arbitrary-layout recognition +algorithm, actual physical caller, merge controller, movement, stock, +precision, native cost, reversible cleanup and complete supplier bill remain +outside scope. No new kappa or multiplication theorem is claimed. Selected +scientific cold replay, predecessor scientific suites, Lean and Docker are unrun. + +[SOURCES.json](SOURCES.json) pins all source documents as historical +provenance. No predecessor implementation or live external mathematical +input is required by the direct verifier, including in a standalone export. + +## Open next questions + +- Which further minimal forbidden patterns characterize two stable two-lane + passes? Test the displayed four-cycle against one named layout before + seeking a constructive factorization. The complete basis and a general + recognition algorithm remain missing. +- Does one current physical producer/consumer layout contain this obstruction + as a record-order pattern? Pin its splitting and merging contract, then + price its controller, movement and cleanup. No actual caller is bound here. + +## Implementation bounds + +The checker has no recursion, solver, subprocess, network access, dynamic +code execution or shared mutable state. Mathematical inputs are fixed. +Dimensions are at most ten. The largest pair loop has exactly 4,862 squared +iterations; the normalized lane loop has exactly four to the ninth. All +functions fit within sixty physical lines. Explicit exceptions preserve +all checks under optimized Python. Warning-strict execution and in-memory +AST compilation provide the available interpreter diagnostics. No separate +lint/type analyzer or shared build configuration is changed. + +Power of Ten rule 3 requires a managed-runtime deviation. CPython allocates +integers, tuples, sets and bytes during this terminating certificate replay. +Two sets of at most 362,880 nine-byte layouts and catalogues of at most 16,796 +ten-record tuples bound live collections. The joined hash payload has at +most 9 times 362,880 bytes. This is not a fixed-allocation online controller; +a native online implementation would require a separate capacity contract. diff --git a/research/two-pass-width-obstruction/SOURCES.json b/research/two-pass-width-obstruction/SOURCES.json new file mode 100644 index 0000000000..b9d477a102 --- /dev/null +++ b/research/two-pass-width-obstruction/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/bit-free-complex-supplier/README.md", + "usage": "provenance", + "git_blob": "86ef9ad3871b39b2c5f90da1682ddf635b0082de", + "sha256": "ecf46acd8300adf05ef5cd2eee39264511d32c29b433fa60bc7e80e2206757cb" + }, + { + "path": "research/permutation-lds-product/README.md", + "usage": "provenance", + "git_blob": "1dac3b7b6b4b85d4ce8ec3b29be5d33ea25d835e", + "sha256": "7ce8ab3caffa4846c000806981993b5f0b3f7984a43f54982c59e564f179cd7d" + } + ] +} diff --git a/research/two-pass-width-obstruction/TASK.json b/research/two-pass-width-obstruction/TASK.json new file mode 100644 index 0000000000..4c8289cdd6 --- /dev/null +++ b/research/two-pass-width-obstruction/TASK.json @@ -0,0 +1,88 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. 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.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Minimum-order failure of sufficiency of the two-pass width-product test in unrestricted stable two-lane routing.", + "scope_change_reason": "An original inverse-composition layout question replaces the card's register-algebra construction; only an abstract routing boundary is settled.", + "bottleneck_link": "A width-product bound alone cannot fund a two-pass implementation of a proposed layout. This is a side result at the bit-free layout boundary, without a paid native improvement.", + "budget_minutes": 60, + "stop_rule": "Stop at the first explicit verified obstruction; package its minimum-order certificate and an optimal route without classifying further obstructions.", + "outcome": "negative-result", + "evidence": "PROOF.md and verify.py establish an explicit width-four ten-record layout with exact pass optimum three, and complete two-pass coverage of all width-at-most-four orders through nine records.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Which further minimal forbidden patterns are needed to characterize two stable two-lane passes?", + "why_it_matters": "The width bound does not recognize feasible routes, while a complete obstruction test could support controller design.", + "first_step": "Use the displayed four-cycle as a rejection certificate for one named candidate layout, then seek a constructive factorization when it is absent.", + "blocked_by": "This package proves minimum order and one obstruction, not a complete basis or recognition algorithm." + }, + { + "question": "Does a current physical caller require this obstruction as a record-order pattern?", + "why_it_matters": "Only an actual layout occurrence with a priced stream contract can affect a supplier budget.", + "first_step": "Pin one producer/consumer layout and its permitted splitting and merging operations.", + "blocked_by": "No actual caller, tape controller, movement bill or reversible cleanup is supplied." + } + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19541783", + "prior_work": [ + { + "author": "Matarener", + "pr": 3825, + "role": "abstract stable-lane pass obstruction and bit-free supplier context" + }, + { + "author": "James Reed / jwr404", + "pr": 3839, + "role": "finite forward composition evidence; cited without replay" + }, + { + "author": "Mark Karpilovskij", + "url": "https://www.combinatorics.org/ojs/index.php/eljc/article/view/v26i1p41", + "role": "known general noninclusion; not a new theorem here" + } + ] +} diff --git a/research/two-pass-width-obstruction/VERIFY.json b/research/two-pass-width-obstruction/VERIFY.json new file mode 100644 index 0000000000..091bc825fb --- /dev/null +++ b/research/two-pass-width-obstruction/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Complete nine-record inverse-composition coverage, ten-record factor exclusion, all normalized lane types, literal optimal route and rejecting controls." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "The same complete finite certificate with assertions disabled." + } + ] +} diff --git a/research/two-pass-width-obstruction/verify.py b/research/two-pass-width-obstruction/verify.py new file mode 100644 index 0000000000..17428711ab --- /dev/null +++ b/research/two-pass-width-obstruction/verify.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python3 +"""Exact finite minimum-order certificate for two stable two-lane passes.""" + +import hashlib +import itertools +import json +import math +from pathlib import Path +import sys + + +TARGET = (3, 2, 1, 6, 5, 4, 9, 8, 7, 0) +FILES = ("README.md", "PROOF.md", "TASK.json", "SOURCES.json", + "VERIFY.json", "verify.py") + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def permutation(value): + require(isinstance(value, tuple) and 1 <= len(value) <= 10, + "permutation length must lie in 1..10") + require(all(type(x) is int for x in value), "integer records required") + require(sorted(value) == list(range(len(value))), "invalid record set") + return value + + +def width(value): + """Quadratic longest-decreasing-subsequence dynamic program.""" + permutation(value) + depths = [1] * len(value) + for j in range(len(value)): + for i in range(j): + if value[i] > value[j]: + depths[j] = max(depths[j], depths[i] + 1) + return max(depths) + + +def avoids_321(value): + """Independent literal forbidden-triple predicate.""" + for i, j, k in itertools.combinations(range(len(value)), 3): + if value[i] > value[j] > value[k]: + return False + return True + + +def catalogue(n): + require(type(n) is int and 1 <= n <= 10, "unsupported catalogue size") + words = [()] + for size in range(1, n + 1): + following = [] + for word in words: + for cut in range(size): + if all(word[i] < word[i + 1] + for i in range(cut, size - 2)): + following.append(word[:cut] + (size - 1,) + word[cut:]) + words = following + require(len(words) == len(set(words)), "duplicate catalogue entry") + require(len(words) <= 16796, "catalogue capacity exceeded") + return words + + +def pass_check(before, after, lane_one): + permutation(before) + permutation(after) + require(len(before) == len(after), "record count changed") + require(isinstance(lane_one, frozenset) and lane_one <= set(before), + "invalid lane assignment") + for selected in (False, True): + incoming = tuple(x for x in before if (x in lane_one) == selected) + outgoing = tuple(x for x in after if (x in lane_one) == selected) + require(incoming == outgoing, "lane order changed") + + +def upper_route(): + orders = (tuple(range(10)), (1, 2, 3, 4, 5, 6, 7, 8, 9, 0), + (2, 1, 3, 5, 4, 6, 8, 7, 9, 0), TARGET) + lanes = (frozenset({0}), frozenset({2, 5, 8}), frozenset({3, 6, 9})) + for i in range(3): + pass_check(orders[i], orders[i + 1], lanes[i]) + require(width(TARGET) == 4, "wrong obstruction width") + return {"orders": orders, "lane_one_records": [sorted(x) for x in lanes]} + + +def acyclic(labels): + """Kahn elimination on all first/second-pass order requirements.""" + positions = {x: i for i, x in enumerate(TARGET)} + edges = [set() for _ in range(10)] + for x in range(10): + for y in range(x + 1, 10): + if labels[x] // 2 == labels[y] // 2: + edges[x].add(y) + if labels[x] % 2 == labels[y] % 2: + a, b = (x, y) if positions[x] < positions[y] else (y, x) + edges[a].add(b) + remaining = set(range(10)) + for _ in range(10): + roots = [x for x in remaining + if all(x not in edges[y] for y in remaining)] + if not roots: + return False + remaining.difference_update(roots) + if not remaining: + return True + raise ValueError("topological capacity exhausted") + + +def cycle_certificate(): + positions = {x: i for i, x in enumerate(TARGET)} + inversions = [(x, y) for x in range(10) for y in range(x + 1, 10) + if positions[x] > positions[y]] + admissible = 0 + for tail in itertools.product(range(4), repeat=9): + labels = (0,) + tail + if any(labels[x] == labels[y] for x, y in inversions): + continue + admissible += 1 + a = next(x for x in (1, 2, 3) if labels[x] == 1) + c = next(x for x in (4, 5, 6) if labels[x] == 3) + b = next(x for x in (7, 8, 9) if labels[x] == 2) + require(labels[0] // 2 == labels[a] // 2 and 0 < a, + "first cycle edge missing") + require(labels[a] % 2 == labels[c] % 2 + and positions[a] < positions[c], "second cycle edge missing") + require(labels[c] // 2 == labels[b] // 2 and c < b, + "third cycle edge missing") + require(labels[b] % 2 == labels[0] % 2 + and positions[b] < positions[0], "fourth cycle edge missing") + require(not acyclic(labels), "an acyclic intermediate order exists") + require(admissible == math.factorial(3) ** 3, "incomplete type census") + return {"normalized_assignments": 4 ** 9, "forced_cycles": admissible} + + +def factor_exclusion(): + counts = {} + factors = catalogue(10) + require(len(factors) == 16796, "wrong ten-record catalogue size") + for first in factors: + require(avoids_321(first), "invalid first factor") + inverse = [0] * 10 + for i, x in enumerate(first): + inverse[x] = i + second = tuple(inverse[x] for x in TARGET) + require(tuple(first[x] for x in second) == TARGET, + "factor reconstruction failed") + value = width(second) + require(value > 2, "two-pass factorization found") + counts[value] = counts.get(value, 0) + 1 + return {"first_factors": len(factors), "second_width_counts": counts} + + +def minimal_order(): + factors = catalogue(9) + require(len(factors) == 4862, "wrong nine-record catalogue size") + direct_factors = set() + possible = set() + visited = 0 + for word in itertools.permutations(range(9)): + visited += 1 + if avoids_321(word): + direct_factors.add(word) + if width(word) <= 4: + possible.add(bytes(word)) + require(visited == math.factorial(9), "incomplete permutation scan") + require(set(factors) == direct_factors, "independent catalogues disagree") + reached = {bytes(first[x] for x in second) + for first in factors for second in factors} + require(reached == possible, "nine-record inverse completeness failed") + require(len(reached) == 261808, "unexpected nine-record product class") + for removed in range(10): + raw = [x for x in TARGET if x != removed] + reduced = bytes(x - (x > removed) for x in raw) + require(reduced in reached, "a deletion remains obstructed") + digest = hashlib.sha256(b"".join(sorted(reached))).hexdigest() + return {"permutations": visited, "one_pass_factors": len(factors), + "factor_pairs": len(factors) ** 2, "two_pass_layouts": len(reached), + "deletions": 10, "sorted_layouts_sha256": digest} + + +def expect_invalid(before, after, lanes): + try: + pass_check(before, after, lanes) + except ValueError: + return + raise ValueError("invalid routing control was accepted") + + +def controls(): + expect_invalid((0, 1), (1, 0), frozenset()) + expect_invalid((0, 1), (0, 0), frozenset({0})) + expect_invalid((0, 1), (0,), frozenset({0})) + expect_invalid((0, 1), (0, 1), frozenset({2})) + expect_invalid((0, 1, 2), (2, 1, 0), frozenset({0})) + expect_invalid(tuple(range(10)), TARGET, frozenset({0})) + pass_check((0, 1, 2, 3), (1, 0, 3, 2), frozenset({1, 3})) + pass_check((1, 0, 3, 2), (3, 2, 1, 0), frozenset({2, 3})) + require(width((3, 2, 1, 0)) == 4, "width-four boundary changed") + return {"invalid_routes_rejected": 6, "width_four_two_pass_control": True} + + +def main(): + require(len(sys.argv) == 1, "this verifier takes no arguments") + result = {"route": upper_route(), "cycle": cycle_certificate(), + "exclusion": factor_exclusion(), "minimal_order": minimal_order(), + "controls": controls()} + directory = Path(__file__).resolve().parent + sources = {} + for name in FILES: + payload = (directory / name).read_bytes() + require(len(payload) <= 1048576, "package source capacity exceeded") + sources[name] = hashlib.sha256(payload).hexdigest() + receipt = {"status": "PASS_TWO_PASS_WIDTH_OBSTRUCTION", "result": result, + "python": sys.version.split()[0], "package_sha256": sources} + print(json.dumps(receipt, sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main()