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-main46-original-clear/LICENSE b/research/p104-main46-original-clear/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-main46-original-clear/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/p104-main46-original-clear/NOTICE b/research/p104-main46-original-clear/NOTICE new file mode 100644 index 0000000000..da80d5abdc --- /dev/null +++ b/research/p104-main46-original-clear/NOTICE @@ -0,0 +1,19 @@ +Ali Romman, with substantial OpenAI Codex assistance. Apache-2.0. + +This contribution adds the timed 757/1255 update to PR7604. It retains the +word and complete application of Hao Yan (@FanPUYen), the two-cut criterion +and contractions of SYLforge/PR7603, DreamingOfClouds/PR7601 token settlement, +ToikY/PR7546 and PR7544 native work, and Rohan Arun/PR7113 signed caller. +Clear1nsight, dillona, CubeJerry and all authors of the retained native, +compiler, pricing, precision, BIT and analytic sources retain their credit. + +The application launcher is derived from Hao Yan's PR7604 launcher. Its exact +original bytes and all counted changes are included. The independent row +interpreters retain Hao Yan's authorship. The Gaussian interpreter retains +DreamingOfClouds' authorship. The discovery reader and stock criterion came +from SYLforge's PR7603 archive; the new timed-stock search is local evidence. + +All files under retained/ are unchanged. SOURCE-VERSIONS.json identifies their +exact public source head, paths and SHA256 hashes. The retained PR7604 source +manifest preserves the earlier origin heads and archive-member attribution. +Historical source notes keep their own historical claims and scope. diff --git a/research/p104-main46-original-clear/PROOF.md b/research/p104-main46-original-clear/PROOF.md new file mode 100644 index 0000000000..1e9a1b997d --- /dev/null +++ b/research/p104-main46-original-clear/PROOF.md @@ -0,0 +1,48 @@ +# Main 46 keeps the original #7605 erasure contract + +The baseline is [#7605](https://github.com/CrocSwap/integer-mult-bounds/pull/7605) at `e1d2756eecf03e146338239fee81772a99ba8d4c`, canonical word SHA-256 `e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd`. The candidate canonical word SHA-256 is `aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916`. It applies DreamingOfClouds's [#7610](https://github.com/CrocSwap/integer-mult-bounds/pull/7610) repair at `93fded4340bb08bc1f99d6f18e47a198456a41df` directly to #7605. #7610 proved the same local repair on [#7608](https://github.com/CrocSwap/integer-mult-bounds/pull/7608), whose CLEAR44 row differs. [#7611](https://github.com/CrocSwap/integer-mult-bounds/pull/7611) includes a larger overlapping repair on #7608. The contribution here is the direct fixed-erasure transplant and its verification. + +## Literal edit and exact scalar identity + +All clocks here are zero-based in #7605. The original main-46 itinerary has MOVE45372 `914→245`, ADD45373 `1456 += 46`, ADD45375 `588 -= 46`, and MOVE47958 `245→127`. The candidate drops the first three events and replaces the fourth with `46:914→127`. It keeps the paid MOVE45376 of role 818 from 914 to 245. Immediately before the original ADD45377 `818 += 1456`, insert `588 += 818` and `1456 -= 818`, in that order. The following ADD45378 `818 += 588` and the first later read of role 46 at ADD47959 keep their original order. + +Let $a=x_{588}$, $b=x_{1456}$, and $u=x_{228}+x_{434}+x_{443}-x_{444}$ be normalized input rows. The chart-3 premix at clock zero acts as $(a,b)\mapsto(2a+b-u,-a+u)$, with the six inputs interpreted independently. The literal edit realizes this by the three instructions `588 += 1456`, `1456 -= 588`, and `588 -= 1456`, then an ADD of the four terms of $-u$ into 588 and the four opposite terms into 1456. These eleven scalar instructions have no paid recursive child. + +Let $h$ be the original normalized role-46 row at the chart-245 fork and put $z=u-h-a-b$. Exact reverse substitution of the pinned prefix gives the following arbitrary-input forms immediately before the two corrections. + +| Row | Original at ADD45377 | Candidate before corrections | +| --- | --- | --- | +| 46 | $h$ | $h$ | +| 588 | $a$ | $a-z$ | +| 1456 | $b$ | $b+z$ | +| 818 | $z$ | $z$ | + +Thus the already-paid arrival 818 supplies the exact opposite corrections. Both original rows are recovered before either outward ADD reads them. Role 818 is untouched during the corrections. Role 46 retains its independent row $h$ and reaches the same final chart before ADD47959. The argument allows arbitrary dirty public inputs. + +Early premixing affects other chronological observers, so the fork calculation is paired with an exact differential replay of the complete literal tape. Starting with zero differences, the replay represents each difference by a rational combination of nine pinned baseline read rows. Back-substitution evaluates those rows over the 1,501 independent inputs. A common ADD advances $D_d$ by $qD_s$, an inserted ADD by $q(R_s+D_s)$, and a deleted ADD by $-qR_s$, where $R_s$ is the old source row at that clock. SCALE multiplies the relevant difference, normalized MOVE updates only the chart, and INIT, CLEAR and COPY use the source replay's ownership and zero guards. This checks the chronological effects before and after the fork without assuming that a form is unchanged when no explicit repair is present. + +The differential replay verified equality at all 1,501 public endpoints, emptiness of all 68 owned endpoints, the actual COPY destination guard, every one of the 74 erased rows, and 1,599 owned-interface row comparisons. Every operand is checked against its current chart. The signed native replay separately verified arbitrary-input forward and adjoint endpoints, all affected phases, legal owned paths and the literal word. No owned instruction was added, removed or reordered relative to another owned instruction. The source's 47 owned MOVEs, 74 lifetimes, peak 50, and 68 owned fields are retained. Zero-based CLEAR44 still erases the original full row $-x_{451}-(3/2)x_{902}-(3/2)x_{985}+x_{1495}$ at role 1557 in chart 595. + +## Physical action and all widths + +Charts 914, 245 and 127 have strictly nested spans of dimension 7, 8 and 9. In the chart-245 frame, the vectors 20 and 134 are respectively $18\mathbin{\mathrm{xor}}6$ and $128\mathbin{\mathrm{xor}}6$. All other chart-914 basis vectors occur directly in chart 245. Chart 127 is the full nine-dimensional space. The exact direct pair already occurs as public MOVE46844 on role 497 of #7605. + +Write $F_c$ for the retained canonical signed frame on chart $c$, including absolute phase. The old composite is +$$(F_{127}F_{245}^{-1})(F_{245}F_{914}^{-1})=F_{127}F_{914}^{-1}.$$ +The same equality holds for the adjoints in reverse order. An independent exact Gaussian replay checked the signed Pauli generators and absolute phase of each lowered map, all 512 columns of the forward and adjoint composites, and three rejecting wrong-phase controls. The direct map lowers to a rank-two child with its charged ordinary adapters. + +At a positive column multiplicity $f$, use the retained tensor lift for each chart quotient and identity on spectators. The mixed-product law cancels the equal chart-245 factors at width $f$. The rank-two direct child lifts to rank $2f$ with the retained signed adapters. Coframe scalar ADDs act on equally framed streams with coefficients in the retained exact scalar service, so the normalized rational row equalities hold coordinatewise at the same width. This uses the [selected application tensor-lift and compiler proof](https://github.com/CrocSwap/integer-mult-bounds/blob/bdcb34dd59a05c848e1c07cb3a680b575a35b44a/docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md) and the inherited all-positive-column premise. + +## Directed signed invoice and recovery boundary + +The native change removes two rank-one paid MOVEs, adds one rank-two paid MOVE, and adds eleven net ordinary ADDs per invocation. The unchanged [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) caller has head `07a76c5e2738882c0cb322278e56f6cae3c9885d`, byte SHA-256 `255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc`, and 17 native invocations. In the rebuilt signed invoice the paid delta is `{1:-34,2:+17}`, paid positions fall from 110,366 to 110,349, and the 22,461 productive positions and rank surplus 1,424 are preserved. All 13,600 signed native contacts are included in the occurrence and phase check. + +For $M(C)=\sum_r (T_r-P_r)r^{1-C}$ the moment improves by $17(2-2^{1-C})>0$ for $0Q('0.0036475398278'),'Strictly higher than upper endpoint of #7542 price enclosure'", + f" assert Q(gate['claim'])>=Q('{PUBLIC_CLAIM}'),'Conservative public claim is within the proved application'"), + ("Exact #7481 invoice rejects the new signed claim", "Exact #7605 invoice rejects the new signed claim"), + (" price_record=normal(dict(before=before,after=after,gate=gate,price=price,", f""" public_claim=Q('{PUBLIC_CLAIM}') + assert public_claim>Q(previous['gate']['raw_bracket'][1]) + assert directed.moment(G.signed(before),public_claim)[1]<0 + public_gate=directed.gate(after,public_claim,public_claim+Q(7,10**14),*map(Q,gate['raw_bracket']),Q(gate['BIT_pin'])) + price_record=normal(dict(public_claim_gate=public_gate,before=before,after=after,gate=gate,price=price,"""), + ('PASS_COMPOSED_7481_7542_COMPLETE_SIGNED_APPLICATION', SIGNED_MARKER), + ("source_head='89eaa9d8cae37c1540de98f2d29a3abaabb96a2b'", "source_head='e1d2756eecf03e146338239fee81772a99ba8d4c'"), + ("component_head='71f5acb0409daf208a865482f3349049dbd3251c'", "component_head='93fded4340bb08bc1f99d6f18e47a198456a41df'"), + ] + return adapt(RETAINED / 'engines/7544-signed.py', patches, root / 'producer54/validation_signed/run.py') + + diff --git a/research/p104-main46-original-clear/checks/check_delta.py b/research/p104-main46-original-clear/checks/check_delta.py new file mode 100644 index 0000000000..7624b88385 --- /dev/null +++ b/research/p104-main46-original-clear/checks/check_delta.py @@ -0,0 +1,195 @@ +"""Replay exact word differences from an immutable baseline and one literal edit.""" +import argparse +from fractions import Fraction +from gzip import decompress +from hashlib import sha256 +import json +from pathlib import Path +from signal import alarm, signal, SIGALRM + + +BASE_WORD = "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd" +PEER_EDITS = "a49e9962e32d13fd91cd8715d888bb1f4305003e63dd25485aa413905e00b8d9" +BASE_GZIP = "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d" + + +def add_scaled(target, source, scale): + for key, value in source.items(): + result = target.get(key, 0) + scale * value + if result: + target[key] = result + else: + target.pop(key, None) + + +def input_row(tape, cut, role, public): + row = {role: Fraction(1)} + for op, dst, *args in reversed(tape[:cut]): + if dst not in row or op == "MOVE": + continue + weight = row[dst] + if op in ("INIT", "CLEAR", "COPY"): + del row[dst] + if op == "SCALE": + row[dst] = weight * Fraction(args[0]) + if op in ("ADD", "COPY"): + add_scaled(row, {args[0]: Fraction(args[1])}, weight) + assert all(role < public for role in row) + return row + + +def span(basis): + points = {0} + for vector in basis: + assert vector not in points + points |= {point ^ vector for point in points} + return points + + +def main(): + assert __debug__ + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--input-root", type=Path, required=True) + parser.add_argument("--candidate", type=Path, required=True) + args = parser.parse_args() + progress = {"clock": None, "checks": 0} + copy_checks = 0 + private_checks = 0 + + def timeout(_signum, _frame): + print(json.dumps({"status": "TIME_CAP", **progress})) + raise SystemExit(124) + + signal(SIGALRM, timeout) + alarm(30) + gz = (args.input_root / "word7605.json.gz").read_bytes() + edits_bin = (args.input_root / "edits7610.json").read_bytes() + assert sha256(gz).hexdigest() == BASE_GZIP + assert sha256(edits_bin).hexdigest() == PEER_EDITS + raw = decompress(gz) + assert sha256(raw).hexdigest() == BASE_WORD + baseline = json.loads(raw) + edits = json.loads(edits_bin) + tape = baseline["program"] + public = baseline["public"] + assert edits["base_events"] + 5 == len(tape) == 76636 and not edits["append"] + deleted = {clock + 5: event for clock, event in edits["delete"]} + inserted = {clock + 5 if clock else 0: events for clock, events in edits["insert_before"]} + assert len(deleted) == len(edits["delete"]) and len(inserted) == len(edits["insert_before"]) + assert all(event == tape[clock] for clock, event in deleted.items()) + assert {event[1] for event in deleted.values()} == {46, 588, 1456} + candidate = json.loads(decompress(args.candidate.read_bytes())) + projected = [event for clock, old in enumerate(tape) + for event in inserted.get(clock, []) + ([] if clock in deleted else [old])] + assert candidate == {**baseline, "program": projected} + + forms = {} + for clock, events in inserted.items(): + for event in events: + if event[0] == "ADD": + forms[(clock, event[2])] = input_row(tape, clock, event[2], public) + for clock, event in deleted.items(): + if event[0] == "ADD": + forms[(clock, event[2])] = input_row(tape, clock, event[2], public) + coefficients = [{} for _ in range(public + baseline["owned_fields"])] + charts = baseline["initial"] + [None] * baseline["owned_fields"] + spans = [span(frame) for frame in baseline["frames"]] + max_terms = 0 + + def check_equal(role, label): + actual = {} + for key, coefficient in coefficients[role].items(): + add_scaled(actual, forms[key], coefficient) + if actual: + index = min(actual) + print(json.dumps({"status": "EXCLUDE_EXACT_DELTA", "label": label, "role": role, + "input": index, "new_minus_old": str(actual[index]), **progress})) + raise SystemExit(2) + progress["checks"] += 1 + + def check_chart(event): + op, dst, *tail = event + if op == "MOVE": + begin, end, owned = tail + assert charts[dst] == begin and owned == (dst >= public) + assert spans[begin] < spans[end] or (owned and spans[end] < spans[begin]) + charts[dst] = end + elif op == "INIT": + assert dst >= public and charts[dst] is None + charts[dst] = tail[0] + elif op == "CLEAR": + assert dst >= public and charts[dst] == tail[0] + charts[dst] = None + else: + assert charts[dst] == tail[-1] and tail[-1] is not None + if op in ("ADD", "COPY"): + assert dst != tail[0] and charts[tail[0]] == tail[-1] + else: + assert op == "SCALE" + + for clock, event in enumerate(tape): + progress["clock"] = clock + for addition in inserted.get(clock, []): + check_chart(addition) + if addition[0] == "MOVE": + continue + op, dst, src, scalar, _ = addition + assert op == "ADD" + q = Fraction(scalar) + add_scaled(coefficients[dst], coefficients[src], q) + add_scaled(coefficients[dst], {(clock, src): q}, 1) + op, dst, *tail = event + if clock in deleted: + if op == "ADD": + add_scaled(coefficients[dst], {(clock, tail[0]): -Fraction(tail[1])}, 1) + else: + assert op == "MOVE" + continue + involved = [dst] + ([tail[0]] if op in ("ADD", "COPY") else []) + has_owned_operand = any(role >= public for role in involved) + if has_owned_operand and op != "INIT": + for role in involved: + check_equal(role, f"owned interface before baseline clock {clock}") + private_checks += 1 + check_chart(event) + if op == "CLEAR": + check_equal(dst, f"CLEAR at baseline clock {clock}") + coefficients[dst].clear() + elif op == "INIT": + coefficients[dst].clear() + elif op == "SCALE" and coefficients[dst]: + q = Fraction(tail[0]) + coefficients[dst] = {key: value * q for key, value in coefficients[dst].items()} + elif op in ("COPY", "ADD"): + if op == "COPY": + check_equal(dst, f"zero COPY destination at baseline clock {clock}") + copy_checks += 1 + coefficients[dst].clear() + if coefficients[tail[0]]: + add_scaled(coefficients[dst], coefficients[tail[0]], Fraction(tail[1])) + if has_owned_operand: + check_equal(dst, f"owned interface after baseline clock {clock}") + private_checks += 1 + max_terms = max(max_terms, len(coefficients[dst])) + + assert charts == baseline["final"] + [None] * baseline["owned_fields"] + assert not any(coefficients[public:]) + for role in range(public): + check_equal(role, "final endpoint") + assert public == 1501 and baseline["owned_fields"] == 68 + assert progress["checks"] == public + 74 + copy_checks + private_checks + canonical = json.dumps(candidate, sort_keys=True, separators=(",", ":")).encode() + receipt = {"status": "PASS_EXACT_NORMALIZED_SCALAR_DIFFERENCE", "source_word_sha256": BASE_WORD, + "peer_edits_sha256": PEER_EDITS, "candidate_canonical_sha256": sha256(canonical).hexdigest(), + "public_endpoint_rows": public, "empty_owned_endpoints": baseline["owned_fields"], + "owned_clear_rows": 74, "events": len(projected), + "zero_COPY_destinations": copy_checks, + "owned_interface_row_checks": private_checks, + "basis_rows": len(forms), "max_form_terms_on_common_event": max_terms, + "last_baseline_clock": progress["clock"], "seconds_cap": 30} + print(json.dumps(receipt, sort_keys=True)) + alarm(0) + + +if __name__ == "__main__": + main() diff --git a/research/p104-main46-original-clear/checks/check_main46_phase.py b/research/p104-main46-original-clear/checks/check_main46_phase.py new file mode 100644 index 0000000000..b2ec506400 --- /dev/null +++ b/research/p104-main46-original-clear/checks/check_main46_phase.py @@ -0,0 +1,74 @@ +"""Check the three literal main-46 chart maps in exact signed arithmetic.""" +import argparse +from copy import deepcopy +import gzip +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path + +WORD_SHA = "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d" +ENGINE_PINS = { + "clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", +} +FRAMES = { + 914: [1, 10, 20, 32, 64, 134, 256], + 245: [1, 6, 10, 18, 32, 64, 128, 256], + 127: [1, 2, 4, 8, 16, 32, 64, 128, 256], +} + + +def sha(data): + return sha256(data).hexdigest() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--word", type=Path, required=True) + parser.add_argument("--engine-root", type=Path, required=True) + parser.add_argument("--all-columns", action="store_true") + args = parser.parse_args() + assert __debug__ + raw = args.word.read_bytes() + assert sha(raw) == WORD_SHA + word = json.loads(gzip.decompress(raw)) + assert all(word["frames"][i] == f for i, f in FRAMES.items()) + assert word["program"][46844] == ["MOVE", 497, 914, 127, False] + for name, expected in ENGINE_PINS.items(): + assert sha((args.engine_root / name).read_bytes()) == expected + compiler = run_path(str(args.engine_root / "clifford_exact.py")) + interp = run_path(str(args.engine_root / "native_verify.py")) + frames = {i: compiler["canonical_frame"](9, tuple(f)) for i, f in FRAMES.items()} + native = {} + for a, b, rank in ((914, 245, 1), (245, 127, 1), (914, 127, 2)): + record, _ = compiler["lower_child"](frames[a].adjoint().then(frames[b])) + assert record["rank"] == rank + expected = interp["adjoint"](interp["frame"](FRAMES[a], 9)) + interp["frame"](FRAMES[b], 9) + native[a, b] = interp["recipe"](record) + interp["equal"](native[a, b], expected, f"canonical {a}→{b}") + damaged = deepcopy(record) + damaged["left"]["phase"] = (damaged["left"]["phase"] + 1) % 4 + try: + interp["equal"](interp["recipe"](damaged), expected, "reject wrong phase") + except ValueError as e: + assert "exact global phase" in str(e) + else: + raise AssertionError("phase control accepted") + via = native[914, 245] + native[245, 127] + direct = native[914, 127] + for label, left, right in (("forward", via, direct), + ("adjoint", interp["adjoint"](via), interp["adjoint"](direct))): + interp["equal"](left, right, label) + if args.all_columns: + for j in range(512): + assert interp["state"](left, j) == interp["state"](right, j), (label, j) + print(json.dumps({"status": "PASS_MAIN46_PHASE", "word_sha256": WORD_SHA, + "engine_pins": ENGINE_PINS, "ranks": [1, 1, 2], + "signed_generator_count": 18, "existing_direct_move_clock": 46844, + "absolute_phase_controls": 3, + "columns_per_direction": 512 if args.all_columns else 1}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-main46-original-clear/checks/emit_main46.py b/research/p104-main46-original-clear/checks/emit_main46.py new file mode 100644 index 0000000000..7f05502a3f --- /dev/null +++ b/research/p104-main46-original-clear/checks/emit_main46.py @@ -0,0 +1,63 @@ +"""Build one candidate from the pinned #7610 edit list and #7605 word.""" +import argparse +from gzip import compress, decompress +from hashlib import sha256 +import json +from pathlib import Path +import signal + +SOURCE_PIN = "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d" +CANONICAL_PIN = "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd" +EDITS_PIN = "a49e9962e32d13fd91cd8715d888bb1f4305003e63dd25485aa413905e00b8d9" + + +def digest(data): + return sha256(data).hexdigest() + + +def canonical(data): + return json.dumps(data, sort_keys=True, separators=(",", ":")).encode() + + +def main(): + assert __debug__ + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--source", required=True, type=Path) + parser.add_argument("--peer-edits", required=True, type=Path) + parser.add_argument("--output", required=True, type=Path) + args = parser.parse_args() + signal.alarm(30) + source, edits = args.source.read_bytes(), args.peer_edits.read_bytes() + assert digest(source) == SOURCE_PIN and digest(edits) == EDITS_PIN + raw = decompress(source) + assert digest(raw) == CANONICAL_PIN + word, plan = json.loads(raw), json.loads(edits) + tape = word["program"] + assert len(tape) - plan["base_events"] == 5 + assert not plan["append"] + deletes, inserts = dict(plan["delete"]), dict(plan["insert_before"]) + assert sorted(deletes) == [45367, 45368, 45370, 47953] + assert sorted(inserts) == [0, 45372, 47953] + for old, event in deletes.items(): + assert tape[old + 5] == event + assert tape[45377] == ["ADD", 818, 1456, "1", 245] + assert tape[47959] == ["ADD", 1019, 46, "1", 127] + adjusted_inserts = {k + 5 if k else 0: v for k, v in inserts.items()} + removed = {k + 5 for k in deletes} + word["program"] = [ + operation for clock, original in enumerate(tape) + for operation in adjusted_inserts.get(clock, []) + ([original] if clock not in removed else []) + ] + candidate = canonical(word) + payload = compress(candidate, mtime=0) + args.output.write_bytes(payload) + print(json.dumps({"status": "LITERAL_CANDIDATE_EMITTED_VERIFICATION_PENDING", + "word_gzip_sha256": digest(payload), "word_canonical_sha256": digest(candidate), + "source_word_gzip_sha256": SOURCE_PIN, "source_word_canonical_sha256": CANONICAL_PIN, + "peer_edits_sha256": EDITS_PIN, "old_event_count": len(tape), + "new_event_count": len(word["program"])}, sort_keys=True)) + signal.alarm(0) + + +if __name__ == "__main__": + main() diff --git a/research/p104-main46-original-clear/checks/pricing.py b/research/p104-main46-original-clear/checks/pricing.py new file mode 100644 index 0000000000..40ec194017 --- /dev/null +++ b/research/p104-main46-original-clear/checks/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-main46-original-clear/checks/recount_main46.py b/research/p104-main46-original-clear/checks/recount_main46.py new file mode 100644 index 0000000000..b2165e4eb4 --- /dev/null +++ b/research/p104-main46-original-clear/checks/recount_main46.py @@ -0,0 +1,203 @@ +"""Independently recount the literal main-46 candidate and its signed invoice.""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from gzip import decompress +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path +import signal + +PINS = { + "word.json.gz": "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d", + "7113-CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "invoice-new.json": "b38afd7ca590b5c4c301ee4fbe0e123f0c7220c2bd1f40c66adf208652e3ce15", + "FINAL.json": "f24baa73a60d084a6d613dad914f1237a5890a049a183b993af39c75dde99add", + "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", +} +OLD_CANONICAL = "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd" +NEW_CANONICAL = "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916" + + +def sha(data): + return sha256(data).hexdigest() + + +def rank(generators): + pivots = {} + for vector in generators: + while vector: + degree = vector.bit_length() + if degree in pivots: + vector ^= pivots[degree] + else: + pivots[degree] = vector + break + return len(pivots) + + +def scaled(counter, n): + return Counter({k: v*n for k, v in counter.items()}) + + +def difference(new, old): + items = set(new) | set(old) + return {r: new[r] - old[r] for r in sorted(items) if new[r] != old[r]} + + +def invoice(word, caller): + frames = word["frames"] + ranks = [rank(frame) for frame in frames] + assert ranks == list(map(len, frames)) + public = word["public"] + active = dict(enumerate(word["initial"])) + paid, scalar_counts, move_pairs, owned_rise = Counter(), Counter(), Counter(), Counter() + life, peak, scalar_upper = 0, 0, 0 + events = Counter(event[0] for event in word["program"]) + paid_rank = {} + for op, role, *tail in word["program"]: + if op == "INIT": + assert role >= public and role not in active + active[role] = tail[0] + life += 1 + peak = max(peak, len(active) - public) + continue + if op == "MOVE": + old, new, owned = tail + assert active[role] == old and owned == (role >= public) + if (old, new) not in paid_rank: + joined_rank = rank(frames[old] + frames[new]) + assert joined_rank == max(ranks[old], ranks[new]) + paid_rank[old, new] = abs(ranks[old] - ranks[new]) + assert paid_rank[old, new] != 0 + assert owned or ranks[new] > ranks[old] + rk = paid_rank[old, new] + move_pairs[old, new] += 1 + paid[rk] += 1 + if owned and ranks[new] > ranks[old]: + owned_rise[rk] += 1 + active[role] = new + continue + assert active[role] == tail[-1] + if op == "CLEAR": + assert role >= public + del active[role] + continue + if op in ("ADD", "COPY"): + assert tail[0] != role and active[tail[0]] == active[role] + else: + assert op == "SCALE" + q = Q(tail[-2]) + a, d = abs(q.numerator), q.denominator + assert 0 < abs(q) < 65535 + scalar_counts[(op, str(q))] += 1 + scalar_upper += 4*(a.bit_length() + d.bit_length() + 1 + + (a.bit_count() if op != "SCALE" else 0)) + assert active == dict(enumerate(word["final"])) + hosted = word["hosted"] + mains = set(word["live"]) | {r+112 for r in word["live"]} | set(hosted["X2"]) | set(hosted["Y2"]) + targets = Counter(ranks[word["final"][r]] - ranks[word["initial"][r]] + for r in range(public) if r not in mains) + assert min(targets) > 0 + caller_paid, caller_targets = Counter(), Counter() + calls = 0 + for event in caller["events"]: + typ, op, *_ = event + if typ == "J": + calls += 1 + continue + count = len(caller["types"][typ]["ports"]) + if op == "QUERY": + caller_paid[1] += count + if op in ("IDLE_ONE", "IDLE_ODD"): + caller_paid[8*len(event[3]) + (op == "IDLE_ODD")] += count + assert calls == caller["stages"] == 17 + assert caller["types"]["A"]["ports"] == hosted["Dports"] + assert sorted(set(range(104)) - set(hosted["Dports"])) == caller["types"]["B"]["ports"] + for typ in caller["types"].values(): + for diag in typ["diagonal"]: + caller_targets[diag[0] % 2 + 8*sum(diag[2:])] += len(typ["ports"]) + assert min(caller_targets) > 0 + return {"paid": scaled(paid, calls) + caller_paid, "targets": scaled(targets, calls) + caller_targets, + "native_paid": paid, "native_targets": targets, "caller_paid": caller_paid, + "caller_targets": caller_targets, "owned_rise": owned_rise, "life": life, + "peak": peak, "events": events, "scalar_counts": scalar_counts, "scalar_upper": scalar_upper, + "move_pairs": move_pairs, "calls": calls} + + +def main(): + assert __debug__ + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("--baseline", type=Path, required=True) + p.add_argument("--candidate", type=Path, required=True) + args = p.parse_args() + signal.alarm(30) + data = {path: (args.baseline / path).read_bytes() for path in PINS} + assert {k: sha(v) for k, v in data.items()} == PINS + old, candidate = decompress(data["word.json.gz"]), decompress(args.candidate.read_bytes()) + assert sha(old) == OLD_CANONICAL and sha(candidate) == NEW_CANONICAL + old, candidate = json.loads(old), json.loads(candidate) + assert {k:v for k,v in old.items() if k != "program"} == {k:v for k,v in candidate.items() if k != "program"} + caller = json.loads(data["7113-CALLER.json"]) + before, after = (invoice(w, caller) for w in (old, candidate)) + source = json.loads(data["invoice-new.json"]) + for label in ("paid", "targets"): + assert before[label] == {int(k):v for k,v in source[label].items()} + assert all(before[k] == after[k] for k in ("owned_rise", "life", "peak", "targets", "native_targets", "caller_paid", "caller_targets")) + native_delta = difference(after["native_paid"], before["native_paid"]) + paid_delta = difference(after["paid"], before["paid"]) + coefficient_delta = difference(after["scalar_counts"], before["scalar_counts"]) + event_delta = difference(after["events"], before["events"]) + pair_delta = difference(after["move_pairs"], before["move_pairs"]) + assert native_delta == {1:-2, 2:1} and paid_delta == {1:-34,2:17} + assert coefficient_delta == {("ADD", "-1"):6, ("ADD", "1"):5} + assert event_delta == {"ADD":11, "MOVE":-1} + assert pair_delta == {(245,127):-1, (914,245):-1, (914,127):1} and before["move_pairs"][914,127] == 1 + assert before["scalar_upper"] == 2196644 and after["scalar_upper"] - before["scalar_upper"] == 176 + + # The remaining caller terms are unchanged under the inherited exact boundary proof. + # Each native MOVE contributes 1000 routing units under the source ordinary formula. + final = json.loads(data["FINAL.json"]) + old_ordinary = final["ordinary_bound"] + ordinary_delta = before["calls"] * (after["scalar_upper"] - before["scalar_upper"] + 1000*event_delta["MOVE"]) + assert ordinary_delta == -14008 and old_ordinary + ordinary_delta < 10**9 + old_lo, old_hi = map(Q, final["raw_crossing"]) + priced = run_path(str(args.baseline / "pricing.py")) + power, cost = priced["power_bounds"], priced["cost"] + gain_bounds = [17*(2-power(2, old_lo)[1]), 17*(2-power(2, old_hi)[0])] + assert gain_bounds[0] > 0 + signed = [] + for row in (before, after): + margin = row["targets"].copy() + margin.subtract(row["paid"]) + assert sum(r*n for r,n in margin.items()) == 1424 + signed.append(margin) + floor = Q("0.0036506661664") + assert floor > old_hi + old_moment, new_moment = (cost(m, floor) for m in signed) + assert old_moment[1] < 0 < new_moment[0] + print(json.dumps({ + "status": "DIRECTED_SIGNED_INVOICE_PASS_NATIVE_AND_FULL_APPLICATION_PENDING", + "pins": PINS, "old_canonical": OLD_CANONICAL, "candidate_canonical": NEW_CANONICAL, + "calls": before["calls"], "native_paid_delta": native_delta, "full_paid_delta": paid_delta, + "paid_positions": [sum(row["paid"].values()) for row in (before, after)], + "target_positions": sum(after["targets"].values()), "surplus": 1424, + "old_native_paid": before["native_paid"], "new_native_paid": after["native_paid"], + "old_full_paid": before["paid"], "new_full_paid": after["paid"], + "productive_targets": after["targets"], "static_caller_paid": after["caller_paid"], + "static_caller_targets": after["caller_targets"], "event_delta": event_delta, + "coefficient_delta": [[*pair, n] for pair,n in coefficient_delta.items()], + "pair_delta": [[*pair,n] for pair,n in pair_delta.items()], + "new_pairs": [], "owned_rises": after["owned_rise"], "lifetimes": after["life"], + "peak": after["peak"], "ordinary_before": old_ordinary, "ordinary_delta": ordinary_delta, + "ordinary_projected_after": old_ordinary + ordinary_delta, + "signed_moment_gain_at_old_crossing": list(map(str, gain_bounds)), "test_floor": str(floor), + "old_moment_at_test_floor": list(map(str, old_moment)), "new_moment_at_test_floor": list(map(str, new_moment)), + "still_required": ["complete native and arbitrary-input replay", "precision and tape", "compiler and outer conditions"], + }, sort_keys=True)) + signal.alarm(0) + + +if __name__ == "__main__": + main() diff --git a/research/p104-main46-original-clear/inputs/7605.sha256 b/research/p104-main46-original-clear/inputs/7605.sha256 new file mode 100644 index 0000000000..818091a217 --- /dev/null +++ b/research/p104-main46-original-clear/inputs/7605.sha256 @@ -0,0 +1,138 @@ +6eb3d3475834b4a45746bb63af503c255ce5e158e91cb86eddf26008cea5c78d research/p104-timed-helper757/.gitattributes +e3f2174470edd904bc6dd65bfb3ee474ad2b959382f82c0fa46af7024d5ff126 research/p104-timed-helper757/APPLICATION-CHANGES.json +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 research/p104-timed-helper757/LICENSE +dd07f1a50c814da884b16359be77c0f3376b119a22ba3178c498517bcd4d519d research/p104-timed-helper757/NOTICE +73380d05edf982f2aef28f6d45aaddb94770fa99c6b20f9b207b1bb872886606 research/p104-timed-helper757/PROOF.md +dc0f47dd704a8b3f7e217b51f7248b1cd78c9b7b1168d4fc9e9028a0de66953b research/p104-timed-helper757/README.md +ce3910302d76c9050c14e1a40edf498be7dd4c5e32773e9ce7384ab99fd27410 research/p104-timed-helper757/SOURCE-VERSIONS.json +9ef68de187d84abf7bd935d9d6ddd9e45ab99ec023bcec0a4b367343399ce962 research/p104-timed-helper757/SOURCES.json +ed37806a1c7cfede8179b854629ad7599e4f892a72dee627cef62112baa7322e research/p104-timed-helper757/TASK.json +6357e5dd25fe9beb6125ab99045c071b4ff09bbd13e0bd21a9abf68ad7aaec7e research/p104-timed-helper757/VALIDATION.md +612bd7799b4be7dbd5cb473515e38e2c1cf01ef8b221c2554a27b9e9ac0cb10e research/p104-timed-helper757/VERIFY.json +b46e39f81116aaa2feb3283d0e53bf95608313240b16e96f174b43fa7b4ab69e research/p104-timed-helper757/application.py +db60577c9cf43d2d7d83b3452c47e3eb43096e566984c3f9c26309238fbc6396 research/p104-timed-helper757/build.py +2c7b1efd6a5faa6353a02726aadc4c553384092e468860ff55759269e955a1d6 research/p104-timed-helper757/data/COLD.json +eae25f06dfa0feab793dbacec2abc7033435574f4e9efbcaa97dbc6d5faf07c2 research/p104-timed-helper757/data/EXACT.json +f24baa73a60d084a6d613dad914f1237a5890a049a183b993af39c75dde99add research/p104-timed-helper757/data/FINAL.json +29e2610d8c4dda6c7bee586ad53d56e251dc4f2b4ebc52718586c563b111cd09 research/p104-timed-helper757/data/NATIVE-RUN.json +0ada1e2e7de8887e6ebbd16cda3c8b9738d71873857657ff4fa6e180653cf888 research/p104-timed-helper757/data/NATIVE.json +51fac6fc89d887296f39493f4eb036deb8a297be25c9ece680e892df6c0c4368 research/p104-timed-helper757/data/PRICE.json +1d13c947bc6beacc8ce8634352c0ceea0e2a0f22e57371644fb631b6c5d69803 research/p104-timed-helper757/data/SIGNED-RUN.json +0dda72ce4f1612ee6c8b6f4078b538f972d24b0108552d6ec50e545a1458cc16 research/p104-timed-helper757/data/SIGNED.json +de38312a6c4d1a011e931a8abe1ba815a5a9c6795d2a67f6cb85602e2146d8f5 research/p104-timed-helper757/data/SOURCE-READBACK.json +ded4c3ea97992ea7e2b1f27d67a910699e04be2622640359361a51e070ea22f1 research/p104-timed-helper757/data/VALIDATION.json +b38afd7ca590b5c4c301ee4fbe0e123f0c7220c2bd1f40c66adf208652e3ce15 research/p104-timed-helper757/data/invoice-new.json +37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d research/p104-timed-helper757/data/word.json.gz +383fb0d515c1a66628573483e0a1bd29b501486fe8fd73d2b1129c89e831e417 research/p104-timed-helper757/independent.py +86e0dbbaf1041db948d2033605ab3ee6f0cc5a94b191d5514218e22df3c6a522 research/p104-timed-helper757/physical.py +041df6d51018977baadbc488e59986a70ed8bc4b56776ec28bf6ccc11ed59520 research/p104-timed-helper757/price.py +7030561af563a5e490a58ed619f08601c960142bb3c04df91a53d354006f9d83 research/p104-timed-helper757/retained/pr7604/FINAL.json +f78bdbd6a8f7b5feebda2be21923bb67745b8ac08d010833cfb31bb63a7f5630 research/p104-timed-helper757/retained/pr7604/NATIVE.json +e984c9868bc47123f7f9f03fa7bae9c8b3d9fb5cad38e9f88a57c660a100d313 research/p104-timed-helper757/retained/pr7604/NOTICE +3db50baf2f5543ca92291a827e534bfdb1a1423c207681e758e43c17a80ad2e2 research/p104-timed-helper757/retained/pr7604/SIGNED.json +1964b4884832f96e17f3db57005b4278dab02219394fce21279a16f5a394b562 research/p104-timed-helper757/retained/pr7604/SOURCE-VERSIONS.json +f22a5c8d0889e7023e534e24b76c19b3c3862ab5e180869235aff761c2dfcbaa research/p104-timed-helper757/retained/pr7604/application.py +99d35a1335a7f7262dddf7357fca0ea27ea95e6df47a009e039ad22ded7a7c99 research/p104-timed-helper757/retained/pr7604/independent.py +fb96f912da7203a775cdddd82870823117a27e2a7f54f5f45956a651728aadd6 research/p104-timed-helper757/retained/pr7604/invoice-new.json +aae5a85746db1abc5145b993e9a9408076f34c53c4bb8040a99b6a39f2685527 research/p104-timed-helper757/retained/pr7604/word.json.gz +3930c22c11da7bc6042cfeb6e459ecb06e4478430037bee3469d034353855fc6 research/p104-timed-helper757/retained/pricing/compare_recursive_invoices.py +52b20f41fd0bb55fa88dccd6015af2ce358917817b9506720f3e60ce681cc3ad research/p104-timed-helper757/retained/pricing/evaluate_recursive_power.py +29dba38fcadd8e3324cc2b8f826987a8ca8828d8f9d690ee99ef57bee8b1a4ed research/p104-timed-helper757/retained/role902/PINS.json +67210595b7b80e0760daff73f7abbd9abe8dedfbbb1ebd1f51812b78f42c0f1c research/p104-timed-helper757/retained/role902/PROOF.md +a0656956fc9ead258bedbc7ba40ac7a268cbe08eef5698be75d8a0985f4ddefc research/p104-timed-helper757/retained/role902/RANKING.md +6f143356b7cf0e6b80932a2247fe6423fd1a4fbaedd70e621f86d34934d8fcce research/p104-timed-helper757/retained/role902/README.md +5ae4cfc96aa890b1b06aa0de688e03d9713b2772fb0f9c6ae7e23ad7d49c479d research/p104-timed-helper757/retained/role902/SOURCES.json +883be395d0d29f18b457b226229fad9137fc83285ac4b23f721748a0c787356d research/p104-timed-helper757/retained/role902/TASK.json +7e89b2cbf9ce6e1e955a996d09f6f41db0bf71b2a00a9afc030be1dbd4a634e0 research/p104-timed-helper757/retained/role902/VERIFICATION.md +c1bc0ed05c13270d933e9ce039630da93301950ca92b0b121272f1fbffca1f44 research/p104-timed-helper757/retained/role902/VERIFY.json +acee323696b18914bd863d55341f92112b48d3d1dc1443c276efb6c396fcc0a9 research/p104-timed-helper757/retained/role902/bench/7481-WORD.json.gz +a4ecb5d836b7c2cd466e9ffb512229198795b87b9697a241dd373b3e4bfe8804 research/p104-timed-helper757/retained/role902/bench/7544-NATIVE.json +0b072ea1a1cfcb74ec48a6b9485eaa03b61b74d9f456a6a75177020e30cdf4e3 research/p104-timed-helper757/retained/role902/bench/7544-SIGNED.json +78e060cbd33ebc4078cabf39e50191a977fb9eb5c41104533079e22da1d9d248 research/p104-timed-helper757/retained/role902/bench/NOTICE +b7633ef72463b079ead5298e9f7b10ddc3365e6474d63f49ce125d26f69ad079 research/p104-timed-helper757/retained/role902/bench/TARIFF-SOURCE.json +255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc research/p104-timed-helper757/retained/role902/bench/inputs/7113-CALLER.json +d9b5d292abb87c87eb3fd3f53501e14d77629ca4adca77a527ff2cf5b58df514 research/p104-timed-helper757/retained/role902/bench/inputs/COMPOSED-APPLICATION.json +926bbb01254b96e9f8a67d4b7c616f89105686ef1acd14438ac2aad06ba58a1c research/p104-timed-helper757/retained/role902/bench/inputs/COMPOSED-WORD.json.gz +f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182 research/p104-timed-helper757/retained/role902/bench/inputs/pricing.py +de0642fdb3149e07a7703330646504d64093891362b8797ef8b1950d7ab5c092 research/p104-timed-helper757/retained/role902/emit/check_role902_rung.py +b556a130f71feb1d02b8a606158ef3243fb6ffbebad56a7eb11ec7d4db9d1bc5 research/p104-timed-helper757/retained/role902/engines/7481-EMISSION.json +26c0e02327ee3f8772ef776d03dfb63c5581063bc3e0631b4110d2d237e06092 research/p104-timed-helper757/retained/role902/engines/7544-native.py +f3a09f651e51b781c2b99244b215131615465423c1fdf044546ecf6a6645088d research/p104-timed-helper757/retained/role902/engines/7544-signed.py +b866d7a16433a93cf06321466f590c9be883aca8573a10ed05bc06f41b337dff research/p104-timed-helper757/retained/role902/engines/RECURRENCE.json +5df94d084e55e61ba9b92b75150cbc69f42453df9c560dcc84ab2f81e62bec66 research/p104-timed-helper757/retained/role902/engines/adapt_native902.py +aa280be1255a9baa44459f4ca298deb03354c82b8489f71f0a283ac5561a15cc research/p104-timed-helper757/retained/role902/engines/adapt_signed902.py +ee0f299ec4185d23acd4a1c29451ebfbd8bc40520e9189da96011b6d4fca51c1 research/p104-timed-helper757/retained/role902/engines/check_final902.py +d213bb365436b7dba9f51d8354ea58dd3f6e5256cbbbabc2784e4c3b0570a8d5 research/p104-timed-helper757/retained/role902/engines/check_recurrence.py +60a743d13f668ef86db4b8215b4d5d04430a671ba6f1fe06d9c1c4c3dfe86da5 research/p104-timed-helper757/retained/role902/engines/interval_gate.py +210c60e320d88c7e41877a95d14460f61ff61c0f80060a3e450590a83f2a4eba research/p104-timed-helper757/retained/role902/engines/run_full_candidate.py +a3a225d99dab3573a20cd69616e4b50b18ec20511f460bdfe3c9a6171b9f914f research/p104-timed-helper757/retained/role902/expected/FINAL.json +f2606c4c6b7f3c9ce181d32294ccfb66abb7305ce6b63b83b8118ac073772b21 research/p104-timed-helper757/retained/role902/expected/NATIVE.json +3f585cf934f021cea5704b16925876f157ab3aca36a860003641a6e21e8b4830 research/p104-timed-helper757/retained/role902/expected/PEER-CHART.json +f1f9ea2c62aae57026671812e3954cb1557bf6a0286d146e5c755f63db53d00e research/p104-timed-helper757/retained/role902/expected/PHYSICAL.json +ba19975e8062fd112a2161d1f093cf6334738090cbe08bc14ec55526d14a96ad research/p104-timed-helper757/retained/role902/expected/PREFLIGHT.json +e2d722fc0486440e25af25b74f270f1292fcf8eceb116e27fcb48f055c96f6c7 research/p104-timed-helper757/retained/role902/expected/SIGNED.json +a0beec65810ba6be75053761eeab6a763506ac224e53c6187d8c8e977e1eefb9 research/p104-timed-helper757/retained/role902/expected/WHOLE.json +6e03624b173b90356e96f845d05fc93153846b863734dc8163ab6c44c602cd32 research/p104-timed-helper757/retained/role902/expected/role902-WORD.json.gz +7d35d7031805d94a434f50bae520c5d7773d80af12fda98b59097eb1b4e4413b research/p104-timed-helper757/retained/role902/independent/check_role902.py +9a1faafd57becff9994ce47551d06bfb735c5704b850a6ab49753269060f7c5c research/p104-timed-helper757/retained/role902/independent/check_role902_grid.py +7326093c2230a204745da4b3dde06dde61cf02a8fe42b2c8a90073fafb0a9bea research/p104-timed-helper757/retained/role902/independent/check_role902_physical.py +c7d81ad6620de5e46abf97259f62da0138b58a02759c3189e57b8ab176db6bd5 research/p104-timed-helper757/retained/role902/independent/engines/audit_native.py +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 research/p104-timed-helper757/retained/role902/independent/engines/clifford_exact.py +3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 research/p104-timed-helper757/retained/role902/independent/engines/native_verify.py +c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 research/p104-timed-helper757/retained/role902/independent/notices/LICENSE +c2f941730e39b08d2d77d628706731beccd0bb2519a66bc7275d280e7f27af5d research/p104-timed-helper757/retained/role902/independent/notices/SHARED-WIRE-STOP-NOTICE +e1fc3cc6f701604560f9ede4f3d536cbf733bf30379628f6fc3f31b62ddfeefd research/p104-timed-helper757/retained/role902/independent/peer_chart.py +0c325386d2d29fbc11da63d36a56fa4c84f8343931b988c19b52f63bde2f28f2 research/p104-timed-helper757/retained/role902/replay.py +2ac2768f9d50a1714d71aee4c62d92bf2ffde9497e1bf91f6bc30105fcbfb7e2 research/p104-timed-helper757/retained/role902/upstream/inputs/REMOTE7480.json +255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc research/p104-timed-helper757/retained/role902/upstream/inputs/pr7113/ODD-TYPE-AB-CALLER.json +b395478a4fb4c1ac3b8d7fc8b1811422dd093012b7a2877b34d391e04ccdd891 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/EARLY-RESULT.json +353a08b679e3a95ae5d5f0f8948bb80bd38298d6a548f5c840a9f58cca19943e research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/ENVIRONMENT.json +6f3548f0015d2dea38522e47ad707ef305b30baccb79a73c1ec20c2ce84f2bfe research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/INPUTS.json +8bd9c26c219f7c16d4648458ab527b000a8834cf1f10ceaab3febb9b76644395 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/NATIVE-RESULT.json +67bc1ec2ecddeb1861010811a94e39bffb01918b73fd2ab1f8fd191b6792850e research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/NOTICE +41da66eb7dc60fdb3949409b29f25a02b474d24e4b6c5f28d58619564e9c82b9 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/PROOF.md +bfef00e991d824f7a3ea0ca2b8b742eeee228606ae3592a326119f59ee8980d7 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/PROPOSED-CLAIM.json +4f8d6b96c0d10a840e082f458a0ac00e1cb6a721dabe4134d96f06827b324314 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/README.md +a5e62524828cb3b794641c7e57b2562a3046cb41e7a25798ba2373c34e285cbe research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/REFERENCE.json +e23677681ae2af37c6ead6cef555f3234c7e7d846b931dd76fad668dcde741f6 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/REPLAY-INTEGRITY.json +2b478706efe9e7c7281a9c466aec8d62a57f35064532b2ecfba6f317cb1956ca research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/REPLAY.txt +0a27c6d6be48ed54a907ba9cad6db5dbf21c8b4bb9c72bda2b6fe35b7e0bba3c research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/RESULT.json +ac7b4473035af648d6073e78b6c39675e706e8194b346bb55ed62a0adc81d593 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/SOURCES.json +41aecedba67502ec9d3e18ea0190557a79a844c457c2b74d42e30b82e70877a2 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/TASK.json +ede7dd2dd3733b9a73f72af9dd7edfe819b49b859c5c76e227ec82cb9c220513 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/VERIFY.json +410a553d06491b965d1f24347cbea12b32c01c95b2a78af5be1b807e42649224 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/WITNESS.json +50bf196026a78b7f6d3539befc22d78aeb6dd518ddcd9f5950c7844bad4c19b0 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/WORD.json.gz +07469494e595cec33f255b1ad8e6653cdb6a1b225f9b2f6625989428b998362e research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/adapt.py +4be79e607cf811db120e309463d63b7ec58cd6a14c1837579f8b59e8d166e0c3 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/construct.py +ceb7a44ef19d72a16db7b43c65c85910d965499d1715436011de32af5d39dbb0 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/derive_grid.py +985085a612a6f69e97162d64db7d7889d815167d0466aabceea3f3913e3ceda6 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/frontier.py +721f839cc48605cccd3629d11456e1fcbb3810a624803ad27e99a1bfd6246211 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/inputs/pr7334.tar.gz +c977cf46a9498d013145f74186081ec67674d11473295df399bca61f8a4e7382 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/packing_reference.py +565caf610453f3ab615dfdd2a97dd1a0ea6228dd4cafe59b27cfbefb84dc0aa8 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/price.py +aa434e4c154a6e1e5ac9d13c3627953069da02b4e0f9e977d9a13bfd1e50aa95 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/source.py +05b549206e38ccf5490aa8fd005d3ab5a33b3e084af0ab920152fad0df9c1f6d research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/verify_caller.py +5792e384ef51f0fd9a1f7fd63de62ef6b3bb0bf45369a099e643dd882df377d4 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/verify_early.py +18b2a8887e03d1e1636062b051fa5ff0900296f1ad9681e29545f3046dc50bc6 research/p104-timed-helper757/retained/role902/upstream/inputs/pr7480/verify_native.py +7a4f49fa4752aeb3dc86a5cf0457b6dfb465aef8c7f567e5c711d4f6e6fa094a research/p104-timed-helper757/retained/token-settled/EXPECTED.json +6840bfb38cbf4421d2a0f0cc1bd99ffc6ce040fd145beee18b326ca041ca8c24 research/p104-timed-helper757/retained/token-settled/NOTICE +5eeb0962c251c3585fc2c05ec23b2a7edbeffc77f38784e189ae4e2b1955935c research/p104-timed-helper757/retained/token-settled/README.md +2fe7497297cc9dc0383d5496e447e1c137b16531998655c2e2ecfb21cf3555c6 research/p104-timed-helper757/retained/token-settled/SOURCES.json +c14fda3b4b1b91c3ed2ec4439c5cebb0890d08616ebeb18824dc26321bf3b1db research/p104-timed-helper757/retained/token-settled/TASK.json +34bdeb1f2760195e3600c8f5be6338bddc8a35a2a6164b6eab35fe3e48e97557 research/p104-timed-helper757/retained/token-settled/VERIFY.json +d7c8041af006475ddd4aa6a884d2309984c63b17ee5baa81f16d9d2b7f266b50 research/p104-timed-helper757/retained/token-settled/chart.py +64ff969251ed20dfb7819526404cd476df6706226c9c921259012df95f5f5f40 research/p104-timed-helper757/retained/token-settled/check.py +6e03624b173b90356e96f845d05fc93153846b863734dc8163ab6c44c602cd32 research/p104-timed-helper757/retained/token-settled/data/base-7546-word.json.gz +05535155f82eb3e906b390fd2734ac42bd06720de2c9a4c62defc9ec9e977ed5 research/p104-timed-helper757/retained/token-settled/data/edits.json +151d26b47dce7567c349e5c6455740c10221226ba1f89aef58cf72e1ec8dc676 research/p104-timed-helper757/retained/token-settled/data/invoice-7546.json +9deafd3564ba3e6f918bb584fb3a8ed5026c3ed11a65cb9bd5cb2940c60cbbeb research/p104-timed-helper757/retained/token-settled/data/invoice-new.json +b12adf21fc476248a1cad9ce67514627593c7cf070129547fb45a9ac8b337fc9 research/p104-timed-helper757/retained/token-settled/data/invoice-zero.json +be97530506ab633c2a76a173a51d13f58b581ee7249338821e6e4994e3104675 research/p104-timed-helper757/retained/token-settled/data/word.json.gz +b6ff4a5567896e3de6a6fbd914bd6d0fc11fc905a410ee021dba2511dd11edf8 research/p104-timed-helper757/retained/token-settled/price.py +50226eabcccc69dfad0272b4ba073e0a06f9d526d2307b32f15a931a7cbd1ece research/p104-timed-helper757/retained/two-contractions/published/PROOF.md +044554acb16ec3bc6ac3804e8292ff414bb4f756296e2e0a85f0ecdb41295dec research/p104-timed-helper757/retained/two-contractions/published/README.md +1998cc3a0474955e08b0ddff4f80f263ec00741d9833cd9c5bc2f4c8ec5bdf7f research/p104-timed-helper757/retained/two-contractions/published/VALIDATION.json +0bf0082cab9b6d2bb6657903a4169a3d04c380927982fc4672a6a44edda79a2a research/p104-timed-helper757/retained/two-contractions/published/replay.zip +f7140445db95cdaa2479d5e8578f5f3bcda580b34d4dbfd817e0fc6623419f03 research/p104-timed-helper757/retained/two-contractions/published/verify.py +af7938390af7e948d6e217498190bd5f350b31a7db6de37be091a2ff3eac2561 research/p104-timed-helper757/retained/two-contractions/receipt.json +b3b991e9fc8d9eb684d2ee80ca477a04ad72106d6eee3f41f7b2284800c25d22 research/p104-timed-helper757/retained/two-contractions/word.json.gz +01bf8168f634bb34a232dc63c8c2f2aab7ea4ded19ec071fa5089e4886a7e94b research/p104-timed-helper757/verify.py diff --git a/research/p104-main46-original-clear/inputs/edits7610.json b/research/p104-main46-original-clear/inputs/edits7610.json new file mode 100644 index 0000000000..65a5109016 --- /dev/null +++ b/research/p104-main46-original-clear/inputs/edits7610.json @@ -0,0 +1 @@ +{"base_events":76631,"delete":[[45367,["MOVE",46,914,245,false]],[45368,["ADD",1456,46,"1",245]],[45370,["ADD",588,46,"-1",245]],[47953,["MOVE",46,245,127,false]]],"insert_before":[[0,[["ADD",588,1456,"1",3],["ADD",1456,588,"-1",3],["ADD",588,1456,"-1",3],["ADD",588,228,"-1",3],["ADD",1456,228,"1",3],["ADD",588,434,"-1",3],["ADD",1456,434,"1",3],["ADD",588,443,"-1",3],["ADD",1456,443,"1",3],["ADD",588,444,"1",3],["ADD",1456,444,"-1",3]]],[45372,[["ADD",588,818,"1",245],["ADD",1456,818,"-1",245]]],[47953,[["MOVE",46,914,127,false]]]],"append":[]} \ No newline at end of file diff --git a/research/p104-main46-original-clear/receipts/7605-replay.json b/research/p104-main46-original-clear/receipts/7605-replay.json new file mode 100644 index 0000000000..6da59c2fef --- /dev/null +++ b/research/p104-main46-original-clear/receipts/7605-replay.json @@ -0,0 +1,96 @@ +{ + "pull_request": 7605, + "head": "e1d2756eecf03e146338239fee81772a99ba8d4c", + "canonical_main_at_acquisition": "e54523517d0f03e58352e647c403a5af3e525a57", + "package": "research/p104-timed-helper757", + "python": "Python 3.12.14", + "verify_sha256": "612bd7799b4be7dbd5cb473515e38e2c1cf01ef8b221c2554a27b9e9ac0cb10e", + "final_json_sha256": "f24baa73a60d084a6d613dad914f1237a5890a049a183b993af39c75dde99add", + "word_gzip_sha256": "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d", + "caller": { + "pull_request": 7113, + "head": "07a76c5e2738882c0cb322278e56f6cae3c9885d", + "sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" + }, + "local": { + "start_utc": "2026-11-17T18:34:22Z", + "stop_utc": "2026-11-17T18:41:13Z", + "wall_seconds": 411.39, + "user_seconds": 403.2, + "system_seconds": 3.37, + "exit": 0, + "registered_caps_seconds": [ + 30, + 100, + 60, + 40, + 480, + 480 + ], + "native_seconds": 163.82514816708863, + "signed_seconds": 193.62567045725882, + "registered_result": "PASS_REGISTERED_RESEARCH_PACKAGE", + "closure_file_count": 138 + }, + "comparison": { + "framework_kappa_decimal": "0.003650444244716", + "campaign_delta_kappa_from_replay": "0", + "predecessor_pr": 7604, + "predecessor_crossing_upper": "0.0036502223358273", + "peer_public_gain_strict_lower_bound": "0.0000002219087727" + }, + "registered_final": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate_canonical_sha256": "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd", + "claim": "0.0036504442446", + "framework_claim": "912611061179/250000000000000", + "ordinary_bound": 782699212, + "ordinary_change_over_7546": -41752, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "paid_calls": 110366, + "precision_c": 2430, + "productive_calls": 22461, + "public_H": 14259200000000000000, + "public_claim_derivation": "Weakening the stronger complete framework claim; tape H inequalities also checked at the public gate.", + "public_context_bound_bits": 14085, + "raw_crossing": [ + "3650444244716887763799059457059/1000000000000000000000000000000000", + "36504442447168877637990594570591/10000000000000000000000000000000000" + ], + "signed_physical_map_count": 3040, + "status": "PASS_HELPER757_FINAL_APPLICATION", + "surplus": 1424, + "tape": { + "elementary_records_upper": 25451474528, + "monomial_map_slots": 298502, + "native_invocations": 17, + "scalar_services_upper": 43923200 + }, + "tape_change_over_7546": { + "elementary_records_upper": -17393856, + "monomial_map_slots": -204, + "native_invocations": 0, + "scalar_services_upper": 82688 + } + }, + "hosted": { + "run": 43632689871, + "plan_job": 132562565239, + "plan_conclusion": "failure", + "plan_failure": "test_current_ci_section_matches_selected_record", + "scientific_job": 132563641085, + "scientific_conclusion": "skipped" + } +} diff --git a/research/p104-main46-original-clear/receipts/CHEAP-CONTROLS.json b/research/p104-main46-original-clear/receipts/CHEAP-CONTROLS.json new file mode 100644 index 0000000000..fa3f3a7423 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/CHEAP-CONTROLS.json @@ -0,0 +1 @@ +{"copy_dest_zero": true, "copy_event": ["COPY", 1525, 770, "1", 115], "copy_new_clock": 33980, "copy_old_clock": 33969, "copy_source_row_unchanged": true, "correction_source_nonzero": [36, "1/2"], "omission_separates": [{"endpoint": 588, "good": "0", "input": 36, "omitted": "-1/2"}, {"endpoint": 818, "good": "0", "input": 36, "omitted": "-1/4"}], "status": "PASS_EXACT_ADAPTER_CONTROL_PREFLIGHT"} diff --git a/research/p104-main46-original-clear/receipts/EXACT.json b/research/p104-main46-original-clear/receipts/EXACT.json new file mode 100644 index 0000000000..60ebd56333 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/EXACT.json @@ -0,0 +1 @@ +{"basis_rows": 9, "candidate_canonical_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", "empty_owned_endpoints": 68, "events": 76646, "last_baseline_clock": 76635, "max_form_terms_on_common_event": 8, "owned_clear_rows": 74, "owned_interface_row_checks": 1599, "peer_edits_sha256": "a49e9962e32d13fd91cd8715d888bb1f4305003e63dd25485aa413905e00b8d9", "public_endpoint_rows": 1501, "seconds_cap": 30, "source_word_sha256": "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd", "status": "PASS_EXACT_NORMALIZED_SCALAR_DIFFERENCE", "zero_COPY_destinations": 1} diff --git a/research/p104-main46-original-clear/receipts/FINAL.json b/research/p104-main46-original-clear/receipts/FINAL.json new file mode 100644 index 0000000000..cbe14b640f --- /dev/null +++ b/research/p104-main46-original-clear/receipts/FINAL.json @@ -0,0 +1,51 @@ +{ + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate_canonical_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "claim": "0.0036506661663", + "comparator_claim": "912611061179/250000000000000", + "comparator_crossing": [ + "3650444244716887763799059457059/1000000000000000000000000000000000", + "36504442447168877637990594570591/10000000000000000000000000000000000" + ], + "framework_claim": "3650666180757/1000000000000000", + "ordinary_bound": 782685204, + "ordinary_change_over_7605": -14008, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "paid_calls": 110349, + "precision_c": 2430, + "productive_calls": 22461, + "public_H": 14259200000000000000, + "public_claim_derivation": "Weakening the stronger complete framework claim; tape H inequalities also checked at the public gate.", + "public_context_bound_bits": 14085, + "raw_crossing": [ + "36506661807577608622666732886141/10000000000000000000000000000000000", + "18253330903788804311333366443071/5000000000000000000000000000000000" + ], + "signed_physical_map_count": 3040, + "status": "PASS_MAIN46_FINAL_APPLICATION", + "surplus": 1424, + "tape": { + "elementary_records_upper": 25448575552, + "monomial_map_slots": 298468, + "native_invocations": 17, + "scalar_services_upper": 43929184 + }, + "tape_change_over_7605": { + "elementary_records_upper": -2898976, + "monomial_map_slots": -34, + "native_invocations": 0, + "scalar_services_upper": 5984 + } +} diff --git a/research/p104-main46-original-clear/receipts/INVOICE.json b/research/p104-main46-original-clear/receipts/INVOICE.json new file mode 100644 index 0000000000..9b9ccd1578 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/INVOICE.json @@ -0,0 +1 @@ +{"calls": 17, "candidate_canonical": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", "coefficient_delta": [["ADD", "-1", 6], ["ADD", "1", 5]], "event_delta": {"ADD": 11, "MOVE": -1}, "full_paid_delta": {"1": -34, "2": 17}, "lifetimes": 74, "native_paid_delta": {"1": -2, "2": 1}, "new_full_paid": {"1": 68231, "2": 14450, "3": 14076, "4": 3808, "5": 5848, "6": 272, "7": 187, "8": 741, "9": 32, "16": 416, "24": 416, "32": 416, "40": 416, "48": 416, "56": 416, "64": 208}, "new_moment_at_test_floor": ["55585235493653218226930779888504430527772649/10000000000000000000000000000000000000000000000000", "13896308873413304556732694972126107631957007/2500000000000000000000000000000000000000000000000"], "new_native_paid": {"1": 3991, "2": 850, "3": 828, "4": 224, "5": 344, "6": 16, "7": 11, "8": 5}, "new_pairs": [], "old_canonical": "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd", "old_full_paid": {"1": 68265, "2": 14433, "3": 14076, "4": 3808, "5": 5848, "6": 272, "7": 187, "8": 741, "9": 32, "16": 416, "24": 416, "32": 416, "40": 416, "48": 416, "56": 416, "64": 208}, "old_moment_at_test_floor": ["-214802359914056258525375691451215843256669484351/2500000000000000000000000000000000000000000000000", "-429604719828112517050751382902431686513338941021/5000000000000000000000000000000000000000000000000"], "old_native_paid": {"1": 3993, "2": 849, "3": 828, "4": 224, "5": 344, "6": 16, "7": 11, "8": 5}, "ordinary_before": 782699212, "ordinary_delta": -14008, "ordinary_projected_after": 782685204, "owned_rises": {"1": 10, "2": 4, "3": 1, "4": 6, "5": 1, "6": 1}, "paid_positions": [110366, 110349], "pair_delta": [[245, 127, -1], [914, 127, 1], [914, 245, -1]], "peak": 50, "pins": {"7113-CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", "FINAL.json": "f24baa73a60d084a6d613dad914f1237a5890a049a183b993af39c75dde99add", "invoice-new.json": "b38afd7ca590b5c4c301ee4fbe0e123f0c7220c2bd1f40c66adf208652e3ce15", "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", "word.json.gz": "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d"}, "productive_targets": {"1": 306, "2": 357, "3": 799, "4": 3825, "5": 1360, "6": 731, "7": 323, "8": 544, "9": 10888, "17": 416, "25": 416, "33": 416, "41": 416, "49": 416, "57": 416, "65": 416, "73": 208, "137": 208}, "signed_moment_gain_at_old_crossing": ["859212856771379242819094339146058521416296730259/10000000000000000000000000000000000000000000000000", "859212856771379242819094339146082028864338851237/10000000000000000000000000000000000000000000000000"], "static_caller_paid": {"1": 384, "8": 656, "9": 32, "16": 416, "24": 416, "32": 416, "40": 416, "48": 416, "56": 416, "64": 208}, "static_caller_targets": {"9": 416, "17": 416, "25": 416, "33": 416, "41": 416, "49": 416, "57": 416, "65": 416, "73": 208, "137": 208}, "status": "DIRECTED_SIGNED_INVOICE_PASS_NATIVE_AND_FULL_APPLICATION_PENDING", "still_required": ["complete native and arbitrary-input replay", "precision and tape", "compiler and outer conditions"], "surplus": 1424, "target_positions": 22461, "test_floor": "1140833177/312500000000"} diff --git a/research/p104-main46-original-clear/receipts/NATIVE.json b/research/p104-main46-original-clear/receipts/NATIVE.json new file mode 100644 index 0000000000..bb96c94d43 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/NATIVE.json @@ -0,0 +1,3598 @@ +{ + "adapter": [ + { + "adapted_sha256": "7893f30045cbde0aa8d3ef2401652aa162d79a6e725dce9a1ab1b3520ed64cc1", + "edits": [ + { + "after": "== 1101", + "before": "== 1080", + "occurrences": 1 + }, + { + "after": "fresh_arbitrary_helpers=18 * 1101", + "before": "fresh_arbitrary_helpers=18 * 1080", + "occurrences": 1 + }, + { + "after": "grid.word_run(word, frac=25), grid.caller_run(caller)", + "before": "grid.word_run(word), grid.caller_run(caller)", + "occurrences": 1 + }, + { + "after": " assert src.count(\"(life, peak, owned_count) == (54, 43, 51)\") == 1\n src=src.replace(\"(life, peak, owned_count) == (54, 43, 51)\",\"(life, peak, owned_count) == (74, 50, 68)\")\n exec(compile(src, str(env_path), 'exec'), env.__dict__)", + "before": " exec(compile(src, str(env_path), 'exec'), env.__dict__)", + "occurrences": 1 + } + ], + "module": "producer_rank9", + "source_name": "candidate_gate.py", + "source_sha256": "e71097ca81a082afd7c647324a6c94cb357aeb1084693a095a0f3e0b45a9b11a" + }, + { + "adapted_sha256": "dc0447d40373cca3b228d3d5c195ead094cd0a38982e7c285a9eb2be87592441", + "edits": [ + { + "after": "2**25", + "before": "2**24", + "occurrences": 1 + }, + { + "after": "26 - (abs(value) & -abs(value)).bit_length()", + "before": "25 - (abs(value) & -abs(value)).bit_length()", + "occurrences": 1 + } + ], + "module": "producer_forward", + "source_name": "audit_native.py", + "source_sha256": "c7d81ad6620de5e46abf97259f62da0138b58a02759c3189e57b8ab176db6bd5" + }, + { + "adapted_sha256": "393fb1a9b62155cc160cb1dfc9c5ddb05e1b87ff8a87506262805eb044e98ad1", + "edits": [ + { + "after": "(life, peak, owned_count) == (74, 50, 68)", + "before": "(life, peak, owned_count) == (54, 43, 51)", + "occurrences": 1 + } + ], + "module": "producer_owned_census", + "source_name": "envelopes.py", + "source_sha256": "783da6b5b450fc07434946cb9ec86070dfee01df6b5fa1c385cb024def2c9a9f" + }, + { + "adapted_sha256": "198521def614fe78fa728f1dde2b7fb820c0c0e0ac3ad0c9224dccbf51eac0d5", + "edits": [], + "module": "producer_grid_controls", + "source_name": "independent_bounds.py", + "source_sha256": "198521def614fe78fa728f1dde2b7fb820c0c0e0ac3ad0c9224dccbf51eac0d5" + }, + { + "adapted_sha256": "136f8cd8d9187e4ee50a631270f809e14f21fe33e411bdc5b61f74837861dd10", + "edits": [ + { + "after": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "before": "cca66a7ec924bab47ccd1410968d16e071a01dc6110b5c08040bd207f753d066", + "occurrences": 1 + } + ], + "module": "producer_signed_routes", + "source_name": "physical_child.py", + "source_sha256": "b61be680bb100bb514dd7320117e5de0d04e95d07f450d17633e374b5711bc2e" + } + ], + "caller": { + "bad_outputs": [], + "caller_denominator_height_bound": 431, + "caller_mass_bound": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "caller_mass_ceiling_bits": 642, + "max_terms": 3998 + }, + "charts": { + "all_affected_pairs": [ + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 100 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 327 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 595 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 603 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 618 + ], + "rank": 3 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 1053 + ], + "rank": 5 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 3, + 1083 + ], + "rank": 7 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 42, + 501 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 93, + 310 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 100, + 356 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 128, + 127 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 152, + 127 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 202, + 127 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 245, + 127 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 310, + 716 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 327, + 783 + ], + "rank": 3 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 327, + 907 + ], + "rank": 5 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 356, + 727 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 501, + 513 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 513, + 914 + ], + "rank": 4 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 595, + 603 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 595, + 618 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 603, + 127 + ], + "rank": 7 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 618, + 789 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 618, + 913 + ], + "rank": 4 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 716, + 783 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 716, + 807 + ], + "rank": 3 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 727, + 729 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 729, + 789 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 729, + 808 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 783, + 807 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 783, + 907 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 789, + 808 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 789, + 913 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 807, + 932 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 808, + 933 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 907, + 177 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 913, + 147 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 914, + 127 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 914, + 245 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 932, + 128 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 933, + 152 + ], + "rank": 1 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 1053, + 1083 + ], + "rank": 2 + }, + { + "absolute_phase_verified": true, + "adjoint_columns": 512, + "columns": 512, + "pair": [ + 1083, + 202 + ], + "rank": 1 + } + ], + "changed_public_fields": [ + 46, + 100, + 134, + 166, + 315, + 757, + 761, + 902, + 1077 + ], + "main46_composed_adjoint_columns": 512, + "main46_composed_columns": 512, + "wrong_phase_rejected": true + }, + "controls": { + "doubled_1438_restoration": true, + "doubled_824_compensation": true, + "doubled_early_encoding": true, + "doubled_late_decoding": true, + "extra_uncharged_owned_lifetime": true, + "insufficient_fractional_grid": true, + "insufficient_odd_grid": true, + "missing_helper757_paid_move": true, + "missing_main46_coframe_correction": true, + "missing_main46_paid_move": true, + "wrong_helper757_source": true, + "wrong_main46_move_source": true, + "wrong_move_source": true, + "wrong_output_frame": true + }, + "derived_grid": { + "coefficient_visits": 16463265, + "fractional_bits": 25, + "mass_witness": [ + 66409, + "stored" + ], + "odd_scale": 1125, + "scaled_maximum_mass": "841374570120675/8192", + "unscaled_maximum_mass": "11218327601609/122880" + }, + "forward": { + "coefficient_positions": 2461761, + "copy_guards_checked": 1, + "fractional_bits": 25, + "grid": 1125, + "owned_clear_rows_checked": 74, + "rows": 1569 + }, + "gate": { + "BIT_margin": "11669188645493/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16533000000000000000000", + "alpha": [ + 0.9999999999999989, + 0.9999999999999989 + ], + "claim": "729999622709/200000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.8879962009970827, + 0.8879962009970827 + ], + "derivative_upper": -406321.14643603185, + "gamma": [ + 0.950084189612037, + 0.950084189612037 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364999811354507/100000000000000000": [ + "12452299294730648010864125536956694726797980563553057463022159678014032186787/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124522992947306480108641255369566947267979805635530574630221596780140321869849/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "729999622709/200000000000000": [ + "24904598589460838806076371323466787348951904959358300723677543898042807353429/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62261496473652097015190928308666968372379762398395751809193859745107018384559/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2239, + "moment_margin_float": { + "18249990567729747750070768281253/5000000000000000000000000000000000": [ + 2.8265484819768714e-29, + 2.8265484819768714e-29 + ], + "364999811354507/100000000000000000": [ + 3.635073346843168e-10, + 3.635073346843168e-10 + ], + "36499981135459495500141536562507/10000000000000000000000000000000000": [ + -1.3063300221989229e-29, + -1.3063300221989229e-29 + ] + }, + "moment_margins": { + "18249990567729747750070768281253/5000000000000000000000000000000000": [ + "1413274240988435597632861843791129910280310172374701/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1413274240988435597632861843791129910280310193302731/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "364999811354507/100000000000000000": [ + "18175366734215839751946989348889425425847238395767080224621875357279637/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "18175366734215839751946989348889425425847238395767080224621875378318443/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36499981135459495500141536562507/10000000000000000000000000000000000": [ + "-40822813193716338356823702210527888283566332144677/3125000000000000000000000000000000000000000000000000000000000000000000000000000", + "-653165011099461413709179235368446212537061293373327/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "18249990567729747750070768281253/5000000000000000000000000000000000", + "36499981135459495500141536562507/10000000000000000000000000000000000" + ], + "tested": "364999811354507/100000000000000000", + "written_log_power": 2240 + }, + "grid": { + "dyadic_height": 25, + "maximum_scaled_mass": "841374570120675/8192", + "odd_divisions": { + "ADD": 5830, + "SCALE": 71 + }, + "odd_grid_lcm": 1125, + "opcodes": { + "ADD": 66502, + "CLEAR": 74, + "COPY": 1, + "INIT": 74, + "MOVE": 6269, + "SCALE": 3726 + }, + "owned_lifetimes": 74, + "owned_peak": 50, + "owned_rise_mass": 56, + "owned_rises": { + "1": 10, + "2": 4, + "3": 1, + "4": 6, + "5": 1, + "6": 1 + }, + "paid": { + "1": 3991, + "2": 850, + "3": 828, + "4": 224, + "5": 344, + "6": 16, + "7": 11, + "8": 5 + } + }, + "invoice": { + "P": { + "1": 72222, + "16": 416, + "2": 15300, + "24": 416, + "3": 14904, + "32": 416, + "4": 4032, + "40": 416, + "48": 416, + "5": 6192, + "56": 416, + "6": 288, + "64": 416, + "7": 198, + "8": 762, + "9": 32 + }, + "S": 1520, + "T": { + "1": 324, + "145": 208, + "17": 416, + "2": 378, + "25": 416, + "3": 846, + "33": 416, + "4": 4050, + "41": 416, + "49": 416, + "5": 1440, + "57": 416, + "6": 774, + "65": 416, + "7": 342, + "73": 416, + "8": 576, + "9": 11504 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036499981135459495500141536562506683917632497778977406001520556537", + "raw_crossing": "0.0036499981135459495500141536562506683917632497778977406001520556537" + }, + "limitations": [ + "Five inherited framework assumptions remain.", + "Source-aware retained engines are not independent human/formal acceptance.", + "The complete 17-stage signed application is checked separately." + ], + "native": { + "bad_inputs": [], + "events": 76646, + "helpers": { + "1": 18, + "2": 21, + "3": 47, + "4": 225, + "5": 80, + "6": 43, + "7": 19, + "8": 32, + "9": 616 + }, + "lifetimes": 74, + "owned_peak": 50, + "paid": { + "1": 3991, + "2": 850, + "3": 828, + "4": 224, + "5": 344, + "6": 16, + "7": 11, + "8": 5 + }, + "public": 1501, + "rises": { + "1": 10, + "2": 4, + "3": 1, + "4": 6, + "5": 1, + "6": 1 + } + }, + "ordinary": { + "caller_items": { + "A": { + "envelope": 124674048, + "field_boundary": 94848, + "fused_routes": 0, + "idle_routes": 185472000, + "output_routes": 229056000, + "query_routes": 1152000, + "thin": 6144 + }, + "B": { + "envelope": 39515136, + "field_boundary": 7904, + "fused_routes": 1168000, + "idle_routes": 19552000, + "output_routes": 19088000, + "query_routes": 0, + "thin": 0 + } + }, + "caller_total": 619786080, + "conservative_total": 856712968, + "extra_B_scalar_surcharge": 784256, + "init_clear_allowance": 296, + "lambda_paid_rank1_would_reduce_S_by": 14384, + "lambda_second_charge": 14384000, + "margin_to_billion": 143287032, + "odd_divisions": { + "ADD": 5830, + "SCALE": 71 + }, + "per_input_conversion": 2809872, + "raw_upper": 838734840, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2202, + "moves": 6269, + "owned_lifetime": 296, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9967000, + "scalar_upper": 2196820 + }, + "physical_checks": [ + "verify_host3_odd.py", + "physical.py" + ], + "precision": { + "Kstar_bits": 14093, + "caller": { + "denominator_height": 431, + "maximum_mass": "2031778024781380738667307850969872261300825114412066667930609010754885615256246771273722516797028373875488084463456734932931819440254377992064287155336455679722182496470290893143689397339193405421398373633/137438953472", + "pre_joint_height": 426, + "pre_joint_mass": "766527916529583301313228867197686200815349463045311717713050641430930492401493758087731346459407655106441982454343595473292801327075604294093436993244143470221321807686760749419510412771973080166736111/17179869184" + }, + "context_c": 1342, + "context_height": 451, + "context_mass_bits": 671, + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "28597064155091335647701932703920589586921854994775353752957624589984677014603310723250430184855138961157291356035039238029311642228232675172573379696216013840906742774847107758275711738490323108634930897121958435160338482493995826773445185325233686603956590405139448771812674252264193116393348119664248208603947804845759408498817/58140432535632220280812520816662271754240000000000000000000", + "strict_power_of_two": 896, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Gamma_context": { + "exact": "18429493708835795322679754974708253759246683085966522383832853746205827021633121914110312744997597279139140030046372214280850772551049029388099778256870953711166464600637668731478037327921526595711711000704759844911846919512532885240805279082498883470030022437184045802367975394964821222271686553109099539046758380429864881760634397/279074076171034657347900099919978904420352000000000000000000", + "strict_power_of_two": 903, + "witness": { + "cut": 5112, + "factor": "1", + "kind": "public-return", + "register": 75 + } + }, + "M_caller": { + "exact": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "strict_power_of_two": 619, + "witness": { + "cut": 5076, + "event": 5075, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "M_context": { + "exact": "348561699523123545438618979057729969553234648856675617481076239529074126605788835108311066206930603123956093484118436789180432995389153903074970854188984769519384999017086369973451692300131308622644788436849907307600098032440962118208192989065785294013001969192373419564213406905221507281849506109628793510603281142662797211121208304349/2480658454853641398648000888177590261514240000000000000000000", + "strict_power_of_two": 915, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + }, + "M_joint_entrance": { + "exact": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "strict_power_of_two": 612, + "witness": { + "cut": 4982, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": 39 + } + }, + "Sigma_caller": { + "exact": "18429493708835795322679754974708253759246683085966522383832853746205827021633121914110312744997597279139140030046372214280850772551049029388099778256870953711166464600637668731478037327921526595711711000704759844911846919512532885240805279082498883470030022437184045802367975394964821222271686553109099539046758380429864881760634397/279074076171034657347900099919978904420352000000000000000000", + "strict_power_of_two": 903, + "witness": { + "cut": 5098, + "event": 5097, + "factor": "1", + "kind": "stored", + "register": 75 + } + }, + "Sigma_context": { + "exact": "2257485763693101780695780184985583589009278635790749583600525154001660434992450585660199793138001610103875392324864875193598142458503110627649122350255238946424262601961851391690150318053855328324949475922691815814181619129705613762716344866080600422205817223444326423573003052148269251665165743694659422439019928014909266175705463946357887316725088154345772782739277516126360126662832956241181508444610800691024326825063526210026504936007917572361308438144588511703805638015939/528173421161000257405168428989428514420554051672205145781746293186897519837184000000000000000000000000000000000000000", + "strict_power_of_two": 1198, + "witness": { + "cut": 4983, + "event": 4982, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 19818, + "helper_allocation_premise": "distinct (stage, helper) public inputs as in frozen caller proof", + "independent_adjoint": { + "E_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "28597064155091335647701932703920589586921854994775353752957624589984677014603310723250430184855138961157291356035039238029311642228232675172573379696216013840906742774847107758275711738490323108634930897121958435160338482493995826773445185325233686603956590405139448771812674252264193116393348119664248208603947804845759408498817/58140432535632220280812520816662271754240000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "18429493708835795322679754974708253759246683085966522383832853746205827021633121914110312744997597279139140030046372214280850772551049029388099778256870953711166464600637668731478037327921526595711711000704759844911846919512532885240805279082498883470030022437184045802367975394964821222271686553109099539046758380429864881760634397/279074076171034657347900099919978904420352000000000000000000" + }, + "M_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528104995/131072", + "residual_mass": "18429493708835795322679754974708253759246683085966522383832853746205827021633121914110312744997597279139140030046372214280850772551049029388099778256870953711166464600637668731478037327921526595711711000704759844911846919512532885240805279082498883470030022437184045802367696320888650187614338653009179560142338028429864881760634397/279074076171034657347900099919978904420352000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "joint_coefficient": "3341262452763736608333208973454412950850413153418406702391448781717870354386212730465850137279766193453853839111325961239001898880600732238129365028446669327062277635590277335176110963/4096", + "primitive_coefficient": "97386365324171280012900240624596584740208335418838768849197300645798627964098858911945347609583363839763283834626254278123625524137460265198827318958269714035256037492260512470970582090841/16384", + "residual_mass": "28597064155091335647701932703920589586921854994775353752957624589984677014603310723250430184855138961157291356035039238029311642228232675172573379696216013840906742774847107758275711738490323108634930897121958435160338482493995826773445185325233686603956590405139448771812674252264193116393348119664248208603947804845759408498817/58140432535632220280812520816662271754240000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "71139049377586862629418871698937610393019572652137611543732392122728862032234875850426792200611955874649536689056011773263916935707559511365401032013880904413645069177668118198332454710167691/32768", + "joint_coefficient": "3588816846070975662189139150385916018049768310935423284247506919489598097879366381598784768436344948623399851427080856173768395141863135887379886323692161717893814936281078874126758254305/32768", + "primitive_coefficient": "104601728656160061800829059188189517089489205649710398563826603344774845615386975930430446869514605732253126838851071709850611632285445276658068751933727423823199247050168422471008254528236067/131072", + "residual_mass": "18429493708835795322679754974708253759246683085966522383832853746205827021633121914110312744997597279139140030046372214280850772551049029388099778256870953711166464600637668731478037327921526595711711000704759844911846919512532885240805279082498883470030022437184045802367975394964821222271686553109099539046758380429864881760634397/279074076171034657347900099919978904420352000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "4384", + "entrance_mass": "23859/2", + "event": 49, + "stage": 1 + }, + { + "entrance_defect": "3623719164533627270299358769753710412892369534671654441844672339657372999328010272262037382143428677023606440059682451269190448480456312972958993652187/10645831152764688772121433255004078080000000000000000000", + "entrance_mass": "44760984243/4", + "event": 144, + "stage": 2 + }, + { + "entrance_defect": "10387580397405709477027225395998323146958489038430658022336225341898694194721635479010930029793827700591557435197602073985228028761059204332820372217168943797873/681333193776940081415771728320260997120000000000000000000", + "entrance_mass": "8019347752894898813/16", + "event": 275, + "stage": 3 + }, + { + "entrance_defect": "134050416778866619100721670281143157713141762205930186733267088436022698752514424550195400702583893631788575506482514851616131118903809972515934188043867992332880154421/34066659688847004070788586416013049856000000000000000000", + "entrance_mass": "258721681913211409397548013/2", + "event": 435, + "stage": 4 + }, + { + "entrance_defect": "476142343342941141581450438439605626711406229229943834337909959054574921532259498946677152726272133733303116547582595232657679159119138937183932133999745545190597261786940826237/227111064592313360471923909440086999040000000000000000000", + "entrance_mass": "1102764325780487636837595009524032653/16", + "event": 627, + "stage": 5 + }, + { + "entrance_defect": "854515813333223138947596771834274505698328512467247926775035943605997857259663087053287586786973533775119142003850261398025649119095286857860389429753999057962322293599901162445125779611/170333298444235020353942932080065249280000000000000000000", + "entrance_mass": "659697369868562418053848749577901431896032551/4", + "event": 848, + "stage": 6 + }, + { + "entrance_defect": "12957733930409041624522704927546732750622127019772382784933908286457994102290217775286120364011770828718787303226381659654204552367662074843546921568425228687103088818913464203226112880587375737989/1090133110043104130265234765312417595392000000000000000000", + "entrance_mass": "50017699262951285012300223375874644326538714050483088723/128", + "event": 1101, + "stage": 7 + }, + { + "entrance_defect": "53479495971628217465849721656147538602339505135464405047855350044419079964449242112910379102565203458421692507166225579274252904942893549173333714605219353260192819089554507833970723866231680615571446071803/454222129184626720943847818880173998080000000000000000000", + "entrance_mass": "123860608372223676361208276303474840021608894935793894644443117475/32", + "event": 1383, + "stage": 8 + }, + { + "entrance_defect": "578867790579424455197160315800174674621249020923914476886430642017928259598964332435319176989902965042163153742427476665245048544191161007788501124443339078798527459126244096498586038545412683706902021500869653855627/2725332775107760325663086913281043988480000000000000000000", + "entrance_mass": "446893495694686287960280473450842802655971489871616126572592413520841719161/64", + "event": 1662, + "stage": 9 + }, + { + "entrance_defect": "16613467435609042422617654656395919400159400477220791723175040395022317236921696751615011841119350882682203784293830654831712133360266251501344840365998456601640032592385620521893717754099373534282951869066103337845913391697909808238265044923577044150799866811/681333193776940081415771728320260997120000000000000000000", + "entrance_mass": "1603226733879417057855793968966209778425632456862348198524030211565823693253398434234475406089669867705587698766845597/2", + "event": 3203, + "stage": 10 + }, + { + "entrance_defect": "207238381136012364562985931856615729908718191824273438504216183614311713100093920400220579443444722701462806061555138414910577479940117161692772980160011156758719217258488109744702838124276564091911350793948752355837107898381630846568522300646918707210807423100933574629/10901331100431041302652347653124175953920000000000000000000", + "entrance_mass": "159990737255009044304340266028013949411590186711547802615104749842798991699729693917477577741470706009608765481680513095697397863/256", + "event": 3526, + "stage": 11 + }, + { + "entrance_defect": "924184543989915329760557195291820996105741092570747087421000076003590853378462254274274389078412559544087553591369262141348989303112827902686037832400287509420498540064347190449325537735855037642152933452797904728441196153969615636087239112468179294594994322510185094890652136749/43605324401724165210609390612496703815680000000000000000000", + "entrance_mass": "713482539972112811302498126039122556478474335397824876612540289480809876975347015211250548661355667282704396311981650378099911649135840063/1024", + "event": 3821, + "stage": 12 + }, + { + "entrance_defect": "99397837228460074385044518721452048082727136761375089924802411284700258098295424645028461836930359056226122159109741241581156112835204760704865738093975069964278384728440099163666273919539742141031496618499047257682410550547180982981632099715469422044141994508872710030074132636281001871/4845036044636018356734376734721855979520000000000000000000", + "entrance_mass": "690627858377635566118234917748020783796286454330854789097666289598705747090709204201800639258908872647850357504982405971722609074791401430947671165/1024", + "event": 4088, + "stage": 13 + }, + { + "entrance_defect": "609918463010109012615607091557037030759348252414588829880133285617924095480221155146278007239950117814673825468609427514557231915083107895314088304533301800635696260726496024763100362322361696287331528551161892628721025515451804477907989889244111020131032116000289529527784426430511904551795669173/87210648803448330421218781224993407631360000000000000000000", + "entrance_mass": "470865020405587123936906066570155601953174646068287322382245101819760273515813542612024822098129182481570490831889396523550001544922531326945370763196989399/2048", + "event": 4324, + "stage": 14 + }, + { + "entrance_defect": "60187671533196791081390480112924231541591736284001646037168597682014623829522502932270312175239592756934478744844300411699259827041626047845543869190929814074741215152843839026276954396940976398188080026920486700141494239118096736672202704742393528243717776706565450754837315611264156365945590082875944939/43605324401724165210609390612496703815680000000000000000000", + "entrance_mass": "46465668615402712050475352820015987705766128000689019237904160504542353131957951954454381327545881694314550682714483945959032017848349099581053150524269011108711881/1024", + "event": 4532, + "stage": 15 + }, + { + "entrance_defect": "29401978786138629103651410414158152590193362703607314442387950081925875068374957931041300956730609862357018679273248159149613618408384985811883417634291711230489584656955442991766337975214820617097429104806349507911450485342906479537429600737868271302106775797241370824344514129745270178666007405908106487525037581/348842595213793321684875124899973630525440000000000000000000", + "entrance_mass": "22698711681515933658235268009935719580127806482189476469420786919611768582281970304620813093468639555288906634046185136362302550495196405154606658307111274865117192668126623/8192", + "event": 4709, + "stage": 16 + }, + { + "entrance_defect": "60716460494313777261088737883133817156929703326191548422716246213367483499129514195701892243850244837209429239565264176816140187702664600030491946010735581759700640774160205074018208296467438557376986377505846925073142007065247147444592612614073729598978807058991402881861809435792222271645467312485706025447389658166419/69768519042758664336975024979994726105088000000000000000000", + "entrance_mass": "234369503003028720835110712559034466962392865438574454855472632480300248897620917700915501102797005900029816899906431175273180672543487679750570754841237111980601879269511857634373/8192", + "event": 4858, + "stage": 17 + }, + { + "entrance_defect": "28597064155091335647701932703920589586921854994775353752957624589984677014603310723250430184855138961157291356035039238029311642228232675172573379696216013840906742774847107758275711738490323108634930897121958435160338482493995826773445185325233686603956590405139448771812674252264193116393348119664248208603947804845759408498817/58140432535632220280812520816662271754240000000000000000000", + "entrance_mass": "66231921216838714175335242310174311625441766070329537281095337280001689425837300045521194678022507207573740758259597518292006513594483309822197449388620837179777160688120985448681075810705/4096", + "event": 4982, + "stage": 18 + } + ], + "physical_main_inputs": 3952, + "sites": { + "ADD": 4102, + "IDLE_ODD": 4, + "IDLE_ONE": 96, + "J": 18, + "LAMBDA": 214, + "QUERY": 4, + "SCALE": 298, + "SWAP": 376, + "noninteger_scalar": 1562 + } + }, + "rounded_native": { + "bounds": { + "Gamma": { + "exact": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000", + "strict_power_of_two": 299, + "witness": { + "cut": 76646, + "factor": "1", + "kind": "public-return", + "register": 1498 + } + }, + "M": { + "exact": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "strict_power_of_two": 303, + "witness": { + "cut": 76605, + "factor": "1", + "kind": "stored", + "register": 1498 + } + }, + "Sigma": { + "exact": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000", + "strict_power_of_two": 299, + "witness": { + "cut": 76605, + "factor": "1", + "kind": "stored", + "register": 1498 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 76646, + "lifetimes": 74, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 66502, + "CLEAR": 74, + "COPY": 1, + "INIT": 74, + "MOVE": 6269, + "SCALE": 3726 + }, + "owned_labels": 68, + "peak_owned": 50, + "public": 1501, + "scalars": { + "dyadic": 64328, + "integer": 39869, + "noninteger": 30360, + "odd": 5901 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26668, + "entrance_mass": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000" + }, + "M": { + "active_residual_sites": 26668, + "entrance_mass": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26668, + "entrance_mass": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000" + } + } + }, + "scope": "Exact-child grid and attributed all-fibre error envelope, with one signed unitary per fused event", + "word": { + "coefficient_visits": 16463265, + "dyadic_height": 25, + "mass_witness": [ + 66409, + "stored add" + ], + "maximum_scaled_mass": "841374570120675/8192", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + } + }, + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "7968104406146338620402492984940176012919666809575083913573950620057093702254653/5000000000000000000000000000000000000000000000000000000000000000000000000000000", + "79681044061463386204024929849401760129196668095750839135739506200570937041289361/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003649998113545", + "gain": "0.0000038559278", + "gain_exact": "19279639/5000000000000", + "independent_raw_bracket": [ + "0.00364999811354594955001415365625066", + "0.00364999811354594955001415365625067" + ], + "previous_claim": "729228437149/200000000000000", + "raw_bracket": [ + "0.0036499981135459495500141536562506", + "0.0036499981135459495500141536562507" + ] + }, + "signed_routes": { + "ambient": 153, + "bindings": [ + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 69, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 17, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "old9_route": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 15, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 81, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 64, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 17, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "old9_route": [ + 81, + 82, + 4, + 8, + 67, + 32, + 19, + 128, + 256 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 15, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 81, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 63, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 19, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "old9_route": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 17, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 273, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 60, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 19, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 4, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ] + ], + "old9_inverse": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "old9_route": [ + 273, + 274, + 4, + 8, + 259, + 32, + 64, + 128, + 19 + ], + "ordinary_elementary_units": 35, + "ordinary_route_units": 19, + "port": 17, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 273, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 67, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 30, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 2 + ], + [ + "XOR", + 0, + 2 + ], + [ + "SWAP", + 2, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 2, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 2, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "old9_route": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 27, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 262, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 61, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 30, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 2 + ], + [ + "XOR", + 0, + 2 + ], + [ + "SWAP", + 2, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 2, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 2, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "old9_route": [ + 262, + 261, + 259, + 8, + 16, + 32, + 64, + 128, + 7 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 27, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 262, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 55, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 38, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "old9_route": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 34, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 98, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 68, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 38, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 6 + ], + [ + "XOR", + 0, + 6 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 6 + ], + [ + "XOR", + 6, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 6, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "old9_route": [ + 98, + 97, + 4, + 8, + 16, + 67, + 35, + 128, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 34, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 98, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 60, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 40, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "old9_route": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 35, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 290, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 69, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 40, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 1, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 1, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 8 + ], + [ + "XOR", + 8, + 1 + ], + [ + "XOR", + 5, + 1 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 1 + ] + ], + "old9_inverse": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "old9_route": [ + 290, + 289, + 4, + 8, + 16, + 259, + 64, + 128, + 35 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 35, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 290, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 62, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 47, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 2, + 3 + ], + [ + "XOR", + 0, + 3 + ], + [ + "SWAP", + 3, + 8 + ], + [ + "XOR", + 8, + 2 + ], + [ + "XOR", + 3, + 2 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 3, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "old9_route": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 42, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 268, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 62, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 47, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 2, + 3 + ], + [ + "XOR", + 0, + 3 + ], + [ + "SWAP", + 3, + 8 + ], + [ + "XOR", + 8, + 2 + ], + [ + "XOR", + 3, + 2 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 3, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "old9_route": [ + 268, + 2, + 265, + 261, + 16, + 32, + 64, + 128, + 13 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 42, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 268, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 60, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 52, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 7 + ], + [ + "XOR", + 0, + 7 + ], + [ + "XOR", + 2, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 7 + ], + [ + "XOR", + 7, + 2 + ], + [ + "XOR", + 5, + 2 + ], + [ + "XOR", + 7, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "old9_route": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 47, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 164, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 69, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 52, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 2, + 7 + ], + [ + "XOR", + 0, + 7 + ], + [ + "XOR", + 2, + 5 + ], + [ + "XOR", + 0, + 5 + ], + [ + "SWAP", + 5, + 7 + ], + [ + "XOR", + 7, + 2 + ], + [ + "XOR", + 5, + 2 + ], + [ + "XOR", + 7, + 0 + ], + [ + "XOR", + 5, + 0 + ], + [ + "SWAP", + 0, + 2 + ] + ], + "old9_inverse": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "old9_route": [ + 164, + 2, + 161, + 8, + 16, + 133, + 64, + 37, + 256 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 47, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 164, + "stage": 10 + }, + { + "body_swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "caller_fields": [ + 56, + 57 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 59, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 60, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 3, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 3, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 3 + ], + [ + "XOR", + 4, + 3 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ], + [ + "SWAP", + 0, + 3 + ] + ], + "old9_inverse": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "old9_route": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 55, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 280, + "stage": 9 + }, + { + "body_swaps": [ + [ + 1, + 81 + ], + [ + 2, + 82 + ], + [ + 3, + 83 + ], + [ + 4, + 84 + ], + [ + 5, + 85 + ], + [ + 6, + 86 + ], + [ + 7, + 87 + ], + [ + 8, + 88 + ] + ], + "caller_fields": [ + 58, + 59 + ], + "checks": [ + { + "omitted_q_translation_failures": 512, + "tests": 512, + "width": 1 + }, + { + "omitted_q_translation_failures": 55, + "tests": 128, + "width": 2 + }, + { + "omitted_q_translation_failures": 128, + "tests": 128, + "width": 3 + } + ], + "logical_child_rank": 9, + "native_live_role": 60, + "negative_axis_translation_slot": 0, + "old9_elementary_passes": [ + [ + "XOR", + 3, + 8 + ], + [ + "XOR", + 0, + 8 + ], + [ + "XOR", + 3, + 4 + ], + [ + "XOR", + 0, + 4 + ], + [ + "SWAP", + 4, + 8 + ], + [ + "XOR", + 8, + 3 + ], + [ + "XOR", + 4, + 3 + ], + [ + "XOR", + 8, + 0 + ], + [ + "XOR", + 4, + 0 + ], + [ + "SWAP", + 0, + 3 + ] + ], + "old9_inverse": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "old9_route": [ + 280, + 2, + 4, + 273, + 265, + 32, + 64, + 128, + 25 + ], + "ordinary_elementary_units": 37, + "ordinary_route_units": 19, + "port": 55, + "positive_child_slots": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "q": 280, + "stage": 10 + } + ], + "paid_calls": 32, + "proposed_sha": "9557f713ab4ffb91ede05e8a6d5668c694b9940fc16f2f2d657e2f2b2cac2d3f", + "status": "PASS_PHYSICAL_RANK9_ALGEBRA", + "word_sha": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916" + }, + "source_head": "58a9d052143f5d85295ed2d0163591c47f89a331", + "source_word_canonical_sha256": "5044adee019f073f286789ccb688ffca76d42b60518242bb4daea818d33d337a", + "status": "PASS_MAIN46_COMPLETE_NATIVE", + "timings": [ + { + "elapsed_seconds": 53.00390291213989, + "stage": "authenticated source, complete frame and adjoint checks" + }, + { + "elapsed_seconds": 89.01358270645142, + "stage": "complete forward grid, COPY guards and all public/owned endpoints" + }, + { + "elapsed_seconds": 101.60829591751099, + "stage": "complete ingredient invoices, both directed prices, all outer gates and precision" + }, + { + "elapsed_seconds": 205.03138089179993, + "stage": "all affected Gaussian columns and absolute phase, finite physical replay and signed routes" + } + ], + "word_canonical_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916" +} diff --git a/research/p104-main46-original-clear/receipts/PHASE.json b/research/p104-main46-original-clear/receipts/PHASE.json new file mode 100644 index 0000000000..3c6875a6c4 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/PHASE.json @@ -0,0 +1 @@ +{"absolute_phase_controls": 3, "columns_per_direction": 512, "engine_pins": {"clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", "native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38"}, "existing_direct_move_clock": 46844, "ranks": [1, 1, 2], "signed_generator_count": 18, "status": "PASS_MAIN46_PHASE", "word_sha256": "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d"} diff --git a/research/p104-main46-original-clear/receipts/SIGNED.json b/research/p104-main46-original-clear/receipts/SIGNED.json new file mode 100644 index 0000000000..44e6dbcba0 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/SIGNED.json @@ -0,0 +1,1716 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "c24b2e3d307c1b7cc9ae7cfb1708e8e6e779a5723e2d298a2f524635758a9868", + "check_odd_precision.py": "047e42381b8f2ac47229689afe643574d360b3f00e1d7e292d6474167d195dd3", + "emit_odd_type_ab.py": "6fd9f61f9ba6c726524d1a585d0201b0eac61829ccae6be598f0f0fc1cb64f1a" + }, + "edits": [ + { + "file": "emit_odd_type_ab.py", + "new": "invoice=json.loads((root/\"COHORT-PRICE.json\").read_text())", + "old": "invoice=next(x for x in json.loads((root/\"SHORT-CALLER-RAW-PRICE.json\").read_text())[\"rows\"] if tuple(x[\"shape\"])==shape)" + }, + { + "file": "check_odd_partial_admission.py", + "new": "actual_native=ind.native(w)\nassert actual_native==N and not N[\"bad_inputs\"], \"Fresh complete native inventory and arbitrary-input adjoint\"", + "old": "previous=json.loads((root/\"SHORT-ADMISSION-PARTIAL.json\").read_text())\nassert previous[\"native_sha256\"]==digest and not N[\"bad_inputs\"]" + }, + { + "file": "check_odd_partial_admission.py", + "new": "claim=Q('0.003650666180757')", + "old": "claim=Q(\".00363797977\")" + }, + { + "file": "check_odd_partial_admission.py", + "new": "tested=claim+Q(7,10**17)\nwhile tested>=Q(reference[\"raw_bracket\"][0]):\n tested=claim+(tested-claim)/10", + "old": "tested=claim+Q(7,10**17)" + }, + { + "file": "check_odd_partial_admission.py", + "new": "g=gate(invoice,claim,tested,*bracket,r[\"gate\"][\"BIT_pin\"])\ntry:\n gate(invoice,claim,Q(bracket[0]),*bracket,r[\"gate\"][\"BIT_pin\"])\nexcept AssertionError:\n crossing_probe_rejected=True\nelse:\n raise AssertionError(\"Probe at lower crossing unexpectedly accepted\")", + "old": "g=gate(invoice,claim,tested,*bracket,r[\"gate\"][\"BIT_pin\"])" + }, + { + "file": "check_odd_partial_admission.py", + "new": "\"crossing_probe_rejected\":crossing_probe_rejected,\"scope\":\"Fresh complete changed-native arbitrary-input adjoint;", + "old": "\"scope\":\"Reuse exact same native word all-column adjoint;" + }, + { + "file": "check_odd_precision.py", + "new": "patch('(life, peak, owned_count) == (54, 43, 51)','(life, peak, owned_count) == (74, 50, 68)')\nenv=ModuleType(\"short_envelope\")", + "old": "env=ModuleType(\"short_envelope\")" + }, + { + "file": "check_odd_precision.py", + "new": "", + "old": "previous=json.loads((root/\"SHORT-PRECISION.json\").read_text())" + }, + { + "file": "check_odd_precision.py", + "new": "assert grid_receipt[\"caller_sha256\"]==sha256(cpath.read_bytes()).hexdigest()", + "old": "assert previous[\"native_sha256\"]==sha and grid_receipt[\"caller_sha256\"]==sha256(cpath.read_bytes()).hexdigest()" + }, + { + "file": "check_odd_precision.py", + "new": "wg=grid.word_run(w, frac=25)\nwp,wr=env.native_envelope(w)\nwg=json.loads(json.dumps(wg,default=str));wr=json.loads(json.dumps(wr,default=str))\nassert wg==r[\"precision\"][\"word\"] and wr==r[\"precision\"][\"rounded_native\"], \"Fresh changed-native grid and envelope\"", + "old": "wg=previous[\"native_grid\"]\nwr=previous[\"rounded_native\"]\nwp={key:(Q(v[\"exact\"]),v[\"witness\"]) for key,v in wr[\"bounds\"].items()}" + } + ] + }, + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "catalogue": [ + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "e35fd04bcac592917873c53ae0e96a92258b419c0508a8283bfbb4ab81cf5cc6", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 0, + "slice_stop": 1000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + }, + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "a8f1d9bf2b0a05891a4f8bff837677723559eb8104f2f44589be1d99be9d4e24", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 1000, + "slice_stop": 2000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + }, + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "cc4799c3556660241d9ab659c315f26eaf0b0ca5aca363cfad925d41fddc2a6e", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 2000, + "slice_stop": 3000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + }, + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 40, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "052e5909a9e21695e03a9370faeda899a920d4427671e0904297763f31feb87d", + "main_boundary_digest": "ad959887c990b8862a0e60db3f53d5195a1c9d667c1593f0101adc8db18f27fa", + "main_boundary_pairs": 104, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 3000, + "slice_stop": 3040, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "3650666180757/1000000000000000", + "catalogue": [ + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "e35fd04bcac592917873c53ae0e96a92258b419c0508a8283bfbb4ab81cf5cc6", + "log_sha256": "7945576fe423501032c2131c7972c7f81be9ff801e141cc0ff76dbac7d665b78", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 0, + "slice_stop": 1000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + }, + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "a8f1d9bf2b0a05891a4f8bff837677723559eb8104f2f44589be1d99be9d4e24", + "log_sha256": "8ae7d5f02e61d9d43e43870a3a166e30900a3434eef16fdb196d15cd5d6e6071", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 1000, + "slice_stop": 2000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + }, + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "cc4799c3556660241d9ab659c315f26eaf0b0ca5aca363cfad925d41fddc2a6e", + "log_sha256": "7615929e654a6e405ffd6e84d176824649b7ed7031f25a33d9d7e0b47138e395", + "main_boundary_digest": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "main_boundary_pairs": 0, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 2000, + "slice_stop": 3000, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + }, + { + "catalogue_digest": "005c65b8f1a62e31b9a295c53958c71b54198d22c9bc1a8bfc796b55d0e0f4d9", + "catalogue_size": 3040, + "checked_maps": 40, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2955, + "exact_recipe_digest": "052e5909a9e21695e03a9370faeda899a920d4427671e0904297763f31feb87d", + "log_sha256": "21d3dd71cdcdd04eea1acb39727b1220a4b2496a82da4836c374d8ffc3107c55", + "main_boundary_digest": "ad959887c990b8862a0e60db3f53d5195a1c9d667c1593f0101adc8db18f27fa", + "main_boundary_pairs": 104, + "phase_control_rejected": true, + "scope": "Complete signed Pauli action plus exact Gaussian global phase; for Clifford maps these determine every matrix column. Generic tensor-product and physical grammar application is written in the review. No random-field substitution.", + "slice_start": 3000, + "slice_stop": 3040, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc" + } + ], + "fixed_tape_counts": { + "H": 16540500000000000000000, + "Kstar_bits": 14093, + "actual_ambient": 145, + "caller_odd_scale": 675, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "common_grid": { + "fractional": "p+D", + "signed_width": "p+h+2D+3", + "temp_padding": 26 + }, + "compiler_ambient_cap": 153, + "context_bound_bits": 14104, + "context_c": 2430, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25448575552, + "log_power": 2241, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298468, + "native_invocations": 17, + "native_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "owned_banks_per_raw_occurrence": 1156, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58522, + "native": 1196409 + }, + "scalar_services_upper": 43929184, + "scalar_steps_coefficient": 46063088041984, + "scope": "Exact finite-cost and common-format substitutions in the selected #7000 conditional application proof, using the conservative primitive movement and scalar constants there. The premise is the complete signed native/physical binding and retained compiler, BIT, stock, and outer contracts. This script counts the raw occurrence, not an enumerated top-level compiled multiplier.", + "tested_claim": "3650666180757/1000000000000000" + }, + "native_archive_sha256": "d65839ddd8e514eccb8cb463b90f4043866995d3994908368c940dd302d48adc", + "native_canonical_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "numeric_gate": { + "BIT_margin": "11602381924293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16540500000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "3650666180757/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9081490569755301, + 0.9081490569755301 + ], + "derivative_upper": -381078.6876105095, + "gamma": [ + 0.9409285851217548, + 0.9409285851217548 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3650666180757/1000000000000000": [ + "31136202670785303743614965363409280779616456050018917050212871503214538346989/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "24908962136628242994891972290727424623693164840015133640170297202571630677987/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066618075707/100000000000000000": [ + "12454481068314350101553565492315321741248060804398456067026866624596772453199/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124544810683143501015535654923153217412480608043984560670268666245967724533983/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2240, + "moment_margin_float": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + -1.4537592167843222e-29, + -1.4537592167843222e-29 + ], + "365066618075707/100000000000000000": [ + 2.6746330541346893e-10, + 2.6746330541346893e-10 + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + 2.4176825787183546e-29, + 2.4176825787183546e-29 + ] + }, + "moment_margins": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + "-72687960839216104592741105865664765471788788256909/5000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-726879608392161045927411058656647654717887863268573/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066618075707/100000000000000000": [ + "26746330541346892877954302081078099304086419143655770874124809376583139/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "26746330541346892877954302081078099304086419143655770874124809415482057/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + "1208841289359177283771404011927496526689752175246497/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1208841289359177283771404011927496526689752194622223/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36506661807577608622666732886141/10000000000000000000000000000000000", + "18253330903788804311333366443071/5000000000000000000000000000000000" + ], + "tested": "365066618075707/100000000000000000", + "written_log_power": 2241 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "fddb053073bcb592e992002c8dc202ded0b1ae1b57d8aaa1e4149a03416d5fe4", + "fresh_helpers": 18717, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1501, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68231, + "16": 416, + "2": 14450, + "24": 416, + "3": 14076, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 741, + "9": 32 + }, + "paid_positions": 110349, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22461, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 1156, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + } + }, + "scope": "Conditional component application to the exact 8+9 source with the selected completed BIT predecessor and inherited five assumptions. Checks every normalized endpoint, every paid/helper nested chart map up to exact signed Pauli and absolute phase, caller occurrence/phase, precision, finite scalar and route bounds, and numeric gates. Does not run a compiled Turing machine, select an upstream frontier, or claim human/formal review.", + "source_unit_ordinary": { + "all_caller_scalar_surcharge": 2248928, + "caller_items": { + "A": { + "envelope": 102076416, + "field_boundary": 89856, + "fused_routes": 0, + "idle_routes": 170112000, + "output_routes": 213120000, + "query_routes": 1152000, + "thin": 6144 + }, + "B": { + "envelope": 35730432, + "field_boundary": 7488, + "fused_routes": 1168000, + "idle_routes": 18016000, + "output_routes": 17760000, + "query_routes": 0, + "thin": 0 + } + }, + "caller_total": 559238336, + "charged_caller_odd_conversions": 479232, + "conservative_total": 782685204, + "init_clear_allowance": 296, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 217314796, + "odd_divisions": { + "ADD": 5830, + "SCALE": 71 + }, + "per_input_conversion": 2653768, + "raw_upper": 766023276, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2202, + "moves": 6269, + "owned_lifetime": 296, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9967000, + "scalar_upper": 2196820 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "11602381924293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16540500000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "3650666180757/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9081490569755301, + 0.9081490569755301 + ], + "derivative_upper": -381078.6876105095, + "gamma": [ + 0.9409285851217548, + 0.9409285851217548 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3650666180757/1000000000000000": [ + "31136202670785303743614965363409280779616456050018917050212871503214538346989/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "24908962136628242994891972290727424623693164840015133640170297202571630677987/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066618075707/100000000000000000": [ + "12454481068314350101553565492315321741248060804398456067026866624596772453199/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124544810683143501015535654923153217412480608043984560670268666245967724533983/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2240, + "moment_margin_float": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + -1.4537592167843222e-29, + -1.4537592167843222e-29 + ], + "365066618075707/100000000000000000": [ + 2.6746330541346893e-10, + 2.6746330541346893e-10 + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + 2.4176825787183546e-29, + 2.4176825787183546e-29 + ] + }, + "moment_margins": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + "-72687960839216104592741105865664765471788788256909/5000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-726879608392161045927411058656647654717887863268573/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066618075707/100000000000000000": [ + "26746330541346892877954302081078099304086419143655770874124809376583139/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "26746330541346892877954302081078099304086419143655770874124809415482057/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + "1208841289359177283771404011927496526689752175246497/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1208841289359177283771404011927496526689752194622223/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36506661807577608622666732886141/10000000000000000000000000000000000", + "18253330903788804311333366443071/5000000000000000000000000000000000" + ], + "tested": "365066618075707/100000000000000000", + "written_log_power": 2241 + }, + "crossing_probe_rejected": true, + "finite_rank9_fields": [ + { + "child_rank": 9, + "denominator": 512, + "exponent": 1, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 0 + }, + "spectators": 136, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 262144, + "width": 1 + }, + { + "child_rank": 9, + "denominator": 262144, + "exponent": 2, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 272, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 1024, + "width": 2 + }, + { + "child_rank": 9, + "denominator": 134217728, + "exponent": 3, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 408, + "stage": 8, + "swaps": [ + [ + 1, + 65 + ], + [ + 2, + 66 + ], + [ + 3, + 67 + ], + [ + 4, + 68 + ], + [ + 5, + 69 + ], + [ + 6, + 70 + ], + [ + 7, + 71 + ], + [ + 8, + 72 + ] + ], + "tested_entries": 1024, + "width": 3 + }, + { + "child_rank": 9, + "denominator": 512, + "exponent": 1, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 0 + }, + "spectators": 136, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 262144, + "width": 1 + }, + { + "child_rank": 9, + "denominator": 262144, + "exponent": 2, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 272, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 1024, + "width": 2 + }, + { + "child_rank": 9, + "denominator": 134217728, + "exponent": 3, + "mutated_entries": { + "missing global phase": 8, + "missing multiplicity": 8 + }, + "spectators": 408, + "stage": 9, + "swaps": [ + [ + 1, + 73 + ], + [ + 2, + 74 + ], + [ + 3, + 75 + ], + [ + 4, + 76 + ], + [ + 5, + 77 + ], + [ + 6, + 78 + ], + [ + 7, + 79 + ], + [ + 8, + 80 + ] + ], + "tested_entries": 1024, + "width": 3 + } + ], + "invoice": { + "P": { + "1": 68231, + "16": 416, + "2": 14450, + "24": 416, + "3": 14076, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 741, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036506661807577608622666732886141624491521873554928521214500102703", + "raw_crossing": "0.0036506661807577608622666732886141624491521873554928521214500102703" + }, + "native_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "ordinary": { + "all_caller_scalar_surcharge": 2248928, + "caller_items": { + "A": { + "envelope": 102076416, + "field_boundary": 89856, + "fused_routes": 0, + "idle_routes": 170112000, + "output_routes": 213120000, + "query_routes": 1152000, + "thin": 6144 + }, + "B": { + "envelope": 35730432, + "field_boundary": 7488, + "fused_routes": 1168000, + "idle_routes": 18016000, + "output_routes": 17760000, + "query_routes": 0, + "thin": 0 + } + }, + "caller_total": 559238336, + "charged_caller_odd_conversions": 479232, + "conservative_total": 782685204, + "init_clear_allowance": 296, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 217314796, + "odd_divisions": { + "ADD": 5830, + "SCALE": 71 + }, + "per_input_conversion": 2653768, + "raw_upper": 766023276, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2202, + "moves": 6269, + "owned_lifetime": 296, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9967000, + "scalar_upper": 2196820 + }, + "scope": "Fresh complete changed-native arbitrary-input adjoint; fresh exact signed caller and invoice, ordinary source-unit upper bill, inherited numerical compiler and outer inequalities, and signed rank9 child finite field routes. Fresh integrated physical native/caller and changed-word precision/occurrence application remain separate." + }, + "ODD-CALLER-EXACT-GRID.json": { + "caller_odd_scale": "675", + "caller_odd_scale_bits": 10, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "grid_exponents": [ + 381, + 3, + 2 + ], + "peak_terms": 3752, + "preproduct_exact_divisions": 176874, + "prime_order": [ + 2, + 3, + 5 + ], + "safe_valuation_bound": [ + 381, + 69, + 62 + ], + "scope": "Independent integer Laurent caller endpoint and pre-product divisibility. Valuation bound propagates complete field operators whose Gaussian coefficients have only power-of-two denominators, so odd factors are sourced only from the charged scalar operations. Fixed conversion and storage bounds still needed." + }, + "ODD-FIXED-TAPE-COUNTS.json": { + "H": 16540500000000000000000, + "Kstar_bits": 14093, + "actual_ambient": 145, + "caller_odd_scale": 675, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "common_grid": { + "fractional": "p+D", + "signed_width": "p+h+2D+3", + "temp_padding": 26 + }, + "compiler_ambient_cap": 153, + "context_bound_bits": 14104, + "context_c": 2430, + "elementary_records_per_map_upper": 85264, + "elementary_records_upper": 25448575552, + "log_power": 2241, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298468, + "native_invocations": 17, + "native_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "owned_banks_per_raw_occurrence": 1156, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58522, + "native": 1196409 + }, + "scalar_services_upper": 43929184, + "scalar_steps_coefficient": 46063088041984, + "scope": "Exact finite-cost and common-format substitutions in the selected #7000 conditional application proof, using the conservative primitive movement and scalar constants there. The premise is the complete signed native/physical binding and retained compiler, BIT, stock, and outer contracts. This script counts the raw occurrence, not an enumerated top-level compiled multiplier.", + "tested_claim": "3650666180757/1000000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "fddb053073bcb592e992002c8dc202ded0b1ae1b57d8aaa1e4149a03416d5fe4", + "fresh_helpers": 18717, + "idle_uses": 3392, + "lambda_uses": 11280, + "native_calls": 17, + "native_contact_boundaries": 13600, + "native_public": 1501, + "nonzero_boundary_translations": 13600, + "paid": { + "1": 68231, + "16": 416, + "2": 14450, + "24": 416, + "3": 14076, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 741, + "9": 32 + }, + "paid_positions": 110349, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22461, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 1156, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + } + }, + "patched_application_sha256": "733b31b1cee4567b466fdf834a34460b530f1f87ca6dca9270c0fabb2cf89849", + "scope": "Current caller port and ownership substitution, full phase-polynomial native contact identities on disjoint stage axes, whole signed idle/output geometry, and ordered paid positions. Retains the standard nested chart and local operator premises and requires separate full native replay and complete fixed-tape tariff application.", + "source_reviewer_sha256": "d98987db98553dc55bfc80e3ca47abfcd51c57af6f8cda61101391d8eae94184" + }, + "ODD-PRECISION.json": { + "caller_grid": { + "caller_odd_scale": "675", + "caller_odd_scale_bits": 10, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "grid_exponents": [ + 381, + 3, + 2 + ], + "peak_terms": 3752, + "preproduct_exact_divisions": 176874, + "prime_order": [ + 2, + 3, + 5 + ], + "safe_valuation_bound": [ + 381, + 69, + 62 + ], + "scope": "Independent integer Laurent caller endpoint and pre-product divisibility. Valuation bound propagates complete field operators whose Gaussian coefficients have only power-of-two denominators, so odd factors are sourced only from the charged scalar operations. Fixed conversion and storage bounds still needed." + }, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "context_c": 2430, + "context_height": 406, + "context_mass_bits": 1215, + "native_grid": { + "coefficient_visits": 16463265, + "dyadic_height": 25, + "mass_witness": [ + 66409, + "stored add" + ], + "maximum_scaled_mass": "841374570120675/8192", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "precision_program_sha256": "9362598a87627d4bfd0adb2a6ca02fb7510067a43965a6029f5aa3c6bb7d1ab2", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "3702985034012582048569442666440240422177961728078747939896030293946648406524357575365276589569387738423542185892423794014641822730277743765477941470576352967814882182960768403147912024053111325014262660114609108880593698807541400373398324390368802151913758731464612081473363465423748240878640268406447888498719553208283465410518092016432282399634406740236827606280421187960314500943484284251198353719730110574243585978413607177797258889449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "strict_power_of_two": 1179, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "95565164464824643908427931170340050250259553507501479597127030791260493280652604840528961936688157538629353818972389763192353435676959622805051893487278832488858662396727171485194027678648613200010712159331669697561461870633423533845033204163760440504183275448526842080360623871926564009179459273074468984600205846061972944039955587950882542421596873436885525782693290102946194651746953123902595437066403676349599319565605594630912909151779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000", + "strict_power_of_two": 1184, + "witness": { + "cut": 4783, + "factor": "1", + "kind": "public-return", + "register": 37 + } + }, + "M_caller": { + "exact": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "strict_power_of_two": 897, + "witness": { + "cut": 4751, + "event": 4750, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "M_context": { + "exact": "982542389917550246854426446141927192527938192064281789818052219712344016473850636821070704446215033127484602734662997665787320055623005015336316419913388651045627048923815530345823745875079416642521298216065872358198561380436979687043443732105381768685485670180968317144202781762931897575789735490670150279180717575068715076489116107352533433610883960935747297034527420447133178665939045177137533885747612024605957609383690307030666351084764157/5525030423492596646235338486789670174720000000000000000000000000000000000000000000000", + "strict_power_of_two": 1194, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + }, + "M_joint_entrance": { + "exact": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "strict_power_of_two": 892, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Sigma_caller": { + "exact": "95565164464824643908427931170340050250259553507501479597127030791260493280652604840528961936688157538629353818972389763192353435676959622805051893487278832488858662396727171485194027678648613200010712159331669697561461870633423533845033204163760440504183275448526842080360623871926564009179459273074468984600205846061972944039955587950882542421596873436885525782693290102946194651746953123902595437066403676349599319565605594630912909151779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000", + "strict_power_of_two": 1184, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "292317978940636509773825527475123872815404011408269785873811087215331817965194280083595075091216942042628077847880814217340882320352245619147780706318907449420657454211701172153152727344006717200776200730696149771553749961463748972994813063842425764318334567613803777404622915761341927353796562623665108338466051500274489268940418303397880337088163483616341141906641396775538912350197833721095582921665775993893533820658952836666956840591172296163734536147270279715545260403371788301173409145300266408466211389604793115647979806018286236452515413056714989664008309558699247479318994847483/5646579936229456007840352585096220475858963262973477037060052051047627725209600000000000000000000000000000000000000000000000000000000000000000", + "strict_power_of_two": 1481, + "witness": { + "cut": 4692, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": null + } + } + }, + "fresh_arbitrary_helpers": 18717, + "helper_allocation_premise": "distinct (stage, helper) public inputs as in frozen caller proof", + "independent_adjoint": { + "E_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "3702985034012582048569442666440240422177961728078747939896030293946648406524357575365276589569387738423542185892423794014641822730277743765477941470576352967814882182960768403147912024053111325014262660114609108880593698807541400373398324390368802151913758731464612081473363465423748240878640268406447888498719553208283465410518092016432282399634406740236827606280421187960314500943484284251198353719730110574243585978413607177797258889449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "95565164464824643908427931170340050250259553507501479597127030791260493280652604840528961936688157538629353818972389763192353435676959622805051893487278832488858662396727171485194027678648613200010712159331669697561461870633423533845033204163760440504183275448526842080360623871926564009179459273074468984600205846061972944039955587950882542421596873436885525782693290102946194651746953123902595437066403676349599319565605594630912909151779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "95565164464824643908427931170340050250259553507501479597127030791260493280652604840528961936688157538629353818972389763192353435676959622805051893487278832488858662396727171485194027678648613200010712159331669697561461870633423533845033204163760440504183275448526842080360623871926564009179459273074468984600205846061972944039955587950882542421596873436885059608251307915104168545062130245481603437066403676349599319565605594630912909151779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "3702985034012582048569442666440240422177961728078747939896030293946648406524357575365276589569387738423542185892423794014641822730277743765477941470576352967814882182960768403147912024053111325014262660114609108880593698807541400373398324390368802151913758731464612081473363465423748240878640268406447888498719553208283465410518092016432282399634406740236827606280421187960314500943484284251198353719730110574243585978413607177797258889449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "95565164464824643908427931170340050250259553507501479597127030791260493280652604840528961936688157538629353818972389763192353435676959622805051893487278832488858662396727171485194027678648613200010712159331669697561461870633423533845033204163760440504183275448526842080360623871926564009179459273074468984600205846061972944039955587950882542421596873436885525782693290102946194651746953123902595437066403676349599319565605594630912909151779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "44045271562414607385070694100848878830649970214640998300312786306018062967443468246594561154898058961505472112546768859302383609273393568726960543211039/13307288940955860965151791568755097600000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "66922034578150238850734125616677000110334880306020737947014028803387225408150063273303138789380007025846282587681752248600862797372270484964190970744988805457034399/1277499738331762652654571990600489369600000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "62331487293685206886772084129702705108902752367900150427206486686890230801746132523214754172885497809957029355606512049179760945978148475203387752582973801175306893243040607/1277499738331762652654571990600489369600000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "12732915211945000430383922444540404204408282591355768726957431924905166589202251224898240651185861287229492543601562321600453751479907264191897412548622708609968696177559967987507750297/1277499738331762652654571990600489369600000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "1219176434798837528625752910718673574872220665657151520170935240732385187623068511898965764488922841842162679657155300708778463663165951028265619916607908640580508060640165566980092921152841114373/19162496074976439789818579859007340544000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "130031390635815724459286652607997167419934211872002283705398755036529183397558969964382895878335423083066880912130765163928278663242622509719802327856399514826670799053143954869379684154497279207961125245323/2129166230552937754424286651000815616000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "37859860255896347183274225196849323358416827285941338162955427264485817135048423020055649798144327278626674942545480554049331021046143713034397417628054479971332410123668571368603743629288352326134958245658354699647551129117/2395312009372054973727322482375917568000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "13501687774792728000358308133930218252690344679471934352575407783119325431313257202229409336142306303567357310649631310596095625086456551071333494933132444738984369528871647979187817453466392218558979582516441963312724773762053389971057781163251780219518104466877449252147518345528804660329783914541910405929389236376502890190674312731435553839069592848576657/2762515211746298323117669243394835087360000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "5134035530704154848866877875009413831865786826760395550681072763691246665976684879295308429226989636526566673263502709699556166515780443911706574789185501530508990865589612905129420348975818990405210848933580808252655128123821365455769040295025986500760831569620573044130131005464312062152144462419238376624376519192534903166344550779798179144439285409848275175608765257803/69062880293657458077941731084870877184000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "2449375472212090571730487186129557738812174961048865825602393180915450552828823414725934534619957995165901116944496594127356917396833694313674283570231563749849053262567713224106528067332689576306181765976125547166580187578013793210147824289202575148689979615234180913663555449449290132463167538317875338562948607876006184984547870096917127324622891504614454165779997786085697647722857/2302096009788581935931391036162362572800000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "30779863887579817094420500467515924792101921724783755077836449533463251591357961033275699913369414431052919088715636517416638834784270996805843109272851013761370239340966626476993589341787434803284497001417587706998556100792684197850043005297594212347672618639143252332660779940724838935576719551511127843163505204070817682066567501882148788839060125653545803180648352880862971425089213518148420489/310782961321458561350737789881918947328000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "2027450049141115136923788274397442070532040345246237500683469492937820138978688549560674882230017825805424220209282587771049313732794573675975489370740659724086297752013922221440663321766440267559250665809252237364231729822552964431507892126237148977942160996445099032527641770645442198530753183404939944619654633847841340762893613004508435871480074434245500491257415317872454174732289441544105985831463241/77695740330364640337684447470479736832000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "81425584045785218406278635400285326976091555997870073877262010591005838937694323371187249886923335641653191876411503373573880239010091628865762694388239381480755258009658900826543418273344447143764374728976200004670988261945101479735202753188499630246658565170687220646915353220759415808937236455361674686122504210801701173567482513518706251799226050030532303996747888155387704899574325997774990826759557200427527729/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "1556219079838789694452331908768065748993774043337930690772472352075335188950982745021460726135829863274181239448818905991153539704859813507607314665222468415643644310739965399073250911072965822713489023150115684533419347061466657996717113418007384074672273149177095419677987107096668866257112969805093915942869280501968175445264081171609374281457920252615658806497561649443558129496519766480531595488483704742034490394993659/310782961321458561350737789881918947328000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "1722719638054434564918809945883582091375478041595669193600815630196518385987174123179746869995006962320970100150511735093774263373648872724744029884237683809475235214133445906611643967449986603855672924768732681821694742927392465518256297419581092049219854304509186012785357915091625555099554498329064495926161281407276582188856002410530990041599132241716979147415174050216888443394344983477498681097551210441918158299317113379704697/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "3702985034012582048569442666440240422177961728078747939896030293946648406524357575365276589569387738423542185892423794014641822730277743765477941470576352967814882182960768403147912024053111325014262660114609108880593698807541400373398324390368802151913758731464612081473363465423748240878640268406447888498719553208283465410518092016432282399634406740236827606280421187960314500943484284251198353719730110574243585978413607177797258889449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "event": 4691, + "stage": 17 + } + ], + "physical_main_inputs": 3744, + "sites": { + "ADD": 4126, + "IDLE_ODD": 4, + "IDLE_ONE": 90, + "J": 17, + "LAMBDA": 178, + "QUERY": 4, + "SCALE": 312, + "SWAP": 52, + "noninteger_scalar": 1752 + } + }, + "rounded_native": { + "bounds": { + "Gamma": { + "exact": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000", + "strict_power_of_two": 299, + "witness": { + "cut": 76646, + "factor": "1", + "kind": "public-return", + "register": 1498 + } + }, + "M": { + "exact": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "strict_power_of_two": 303, + "witness": { + "cut": 76605, + "factor": "1", + "kind": "stored", + "register": 1498 + } + }, + "Sigma": { + "exact": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000", + "strict_power_of_two": 299, + "witness": { + "cut": 76605, + "factor": "1", + "kind": "stored", + "register": 1498 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 76646, + "lifetimes": 74, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 66502, + "CLEAR": 74, + "COPY": 1, + "INIT": 74, + "MOVE": 6269, + "SCALE": 3726 + }, + "owned_labels": 68, + "peak_owned": 50, + "public": 1501, + "scalars": { + "dyadic": 64328, + "integer": 39869, + "noninteger": 30360, + "odd": 5901 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26668, + "entrance_mass": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000" + }, + "M": { + "active_residual_sites": 26668, + "entrance_mass": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26668, + "entrance_mass": "78941172123474282481272172643695803739697901574889833881787125239603235858700978302713238015950824336528506150356728366958370199550124467161768665667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25676280650839484381881789045310459168378099316745820846197308455671489604183420171769445342434141399332668403841566594842745453420554753902112177/42583324611058755088485733020016312320000000000000000000" + } + } + }, + "scope": "Fixed integer Laurent grid with charged odd caller scale, and pinned attributed forward/adjoint all-fibre defect engine applied to the emitted 17-stage caller. Each LAMBDA, QUERY and signed/unsigned idle is one unitary with one child defect. The caller allocation assumes independent stage helpers. Full physical application remains separate." + }, + "ODD-TYPE-AB-REPLAY.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "paid": { + "1": 68231, + "16": 416, + "2": 14450, + "24": 416, + "3": 14076, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 741, + "9": 32 + }, + "raw_bracket": [ + "36506661807577608622666732886141/10000000000000000000000000000000000", + "18253330903788804311333366443071/5000000000000000000000000000000000" + ], + "replay": { + "bad_outputs": [], + "caller_denominator_height_bound": 578, + "caller_mass_bound": "854474036861847560509026474008040300059938928517783661039773198072080884690114508581583887358835968277340425788985297793555303569703690223623950838857161290503004459697662544865276977234864184443860251086668962688762176068520364648820282528496698239206689277049335412289161443623602012468587331439851515703/168151253906250000000000000000000", + "caller_mass_ceiling_bits": 910, + "max_terms": 3752 + }, + "scope": "Exact emitted signed Laurent caller endpoint and recomputed native/caller paid and target profiles. Physical address bindings, independent branch-source composition, ordinary units, precision and outer gates are still required.", + "shape": [ + 8, + 9 + ], + "source_word_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "target": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + } + } + }, + "claim": "3650666180757/1000000000000000", + "component_head": "93fded4340bb08bc1f99d6f18e47a198456a41df", + "elapsed_seconds": 226.02480387687683, + "price": { + "after": { + "P": { + "1": 68231, + "16": 416, + "2": 14450, + "24": 416, + "3": 14076, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 741, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036506661807577608622666732886141624491521873554928521214500102703", + "raw_crossing": "0.0036506661807577608622666732886141624491521873554928521214500102703" + }, + "before": { + "P": { + "1": 68265, + "16": 416, + "2": 14433, + "24": 416, + "3": 14076, + "32": 416, + "4": 3808, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 272, + "64": 208, + "7": 187, + "8": 741, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3825, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 544, + "9": 10888 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036504442447168877637990594570590431740683465572645409981409513896", + "raw_crossing": "0.0036504442447168877637990594570590431740683465572645409981409513896" + }, + "gate": { + "BIT_margin": "11602381924293/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16540500000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "3650666180757/1000000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.9081490569755301, + 0.9081490569755301 + ], + "derivative_upper": -381078.6876105095, + "gamma": [ + 0.9409285851217548, + 0.9409285851217548 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "3650666180757/1000000000000000": [ + "31136202670785303743614965363409280779616456050018917050212871503214538346989/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "24908962136628242994891972290727424623693164840015133640170297202571630677987/20000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066618075707/100000000000000000": [ + "12454481068314350101553565492315321741248060804398456067026866624596772453199/10000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124544810683143501015535654923153217412480608043984560670268666245967724533983/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2240, + "moment_margin_float": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + -1.4537592167843222e-29, + -1.4537592167843222e-29 + ], + "365066618075707/100000000000000000": [ + 2.6746330541346893e-10, + 2.6746330541346893e-10 + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + 2.4176825787183546e-29, + 2.4176825787183546e-29 + ] + }, + "moment_margins": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + "-72687960839216104592741105865664765471788788256909/5000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-726879608392161045927411058656647654717887863268573/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066618075707/100000000000000000": [ + "26746330541346892877954302081078099304086419143655770874124809376583139/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "26746330541346892877954302081078099304086419143655770874124809415482057/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + "1208841289359177283771404011927496526689752175246497/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1208841289359177283771404011927496526689752194622223/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36506661807577608622666732886141/10000000000000000000000000000000000", + "18253330903788804311333366443071/5000000000000000000000000000000000" + ], + "tested": "365066618075707/100000000000000000", + "written_log_power": 2241 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", + "old_native": "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd", + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "8592128567713792428190943389260701828200904291966220007309591510344757059139039/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "4296064283856896214095471694630350914100452145983110003654795755172378546961943/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003650666180757", + "gain": "2.21936041E-7", + "gain_exact": "221936041/1000000000000000", + "independent_raw_bracket": [ + "0.00365066618075776086226667328861416", + "0.00365066618075776086226667328861417" + ], + "previous_claim": "912611061179/250000000000000", + "raw_bracket": [ + "0.0036506661807577608622666732886141", + "0.0036506661807577608622666732886142" + ] + }, + "public_claim_gate": { + "BIT_margin": "11602383363/100000000000000", + "BIT_pin": "376669/100000000", + "H": "14259200000000000000", + "alpha": [ + 0.9999999999810673, + 0.9999999999810673 + ], + "claim": "36506661663/10000000000000", + "compiler_gap": "1/100000000000000", + "delta": [ + 0.9081490569660776, + 0.9081490569660776 + ], + "derivative_upper": -381078.6876105095, + "gamma": [ + 0.9409285851084682, + 0.9409285851084682 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "36506661663/10000000000000": [ + "62272405105504208640353817647265837502352415775137222904035361237478941493147/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124544810211008417280707635294531675004704831550274445808070722474957882988257/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066616637/100000000000000": [ + "62272405106647229178651906179732595337063635657865762886963327843378829929/50000000000000000000000000000000000000000000000000000000000000000000000000000", + "62272405106647229178651906179732595337063635657865762886963327843378829929983/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2240, + "moment_margin_float": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + -1.4537592167843222e-29, + -1.4537592167843222e-29 + ], + "365066616637/100000000000000": [ + 5.570137874752516e-06, + 5.570137874752516e-06 + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + 2.4176825787183546e-29, + 2.4176825787183546e-29 + ] + }, + "moment_margins": { + "18253330903788804311333366443071/5000000000000000000000000000000000": [ + "-72687960839216104592741105865664765471788788256909/5000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-726879608392161045927411058656647654717887863268573/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "365066616637/100000000000000": [ + "557013787475251652706232346711564830576884294525323886102368992392915085481/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "557013787475251652706232346711564830576884294525323886102368992392954137387/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36506661807577608622666732886141/10000000000000000000000000000000000": [ + "1208841289359177283771404011927496526689752175246497/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "1208841289359177283771404011927496526689752194622223/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "36506661807577608622666732886141/10000000000000000000000000000000000", + "18253330903788804311333366443071/5000000000000000000000000000000000" + ], + "tested": "365066616637/100000000000000", + "written_log_power": 2241 + }, + "signed_incumbent_rejects_new_claim": true + }, + "source_head": "e1d2756eecf03e146338239fee81772a99ba8d4c", + "status": "PASS_MAIN46_COMPLETE_SIGNED_APPLICATION", + "timings": [ + { + "check": "emit_odd_type_b.py", + "seconds": 2.198425054550171 + }, + { + "check": "emit_odd_type_ab.py", + "seconds": 1.098572015762329 + }, + { + "check": "check_odd_caller_exact_grid.py", + "seconds": 2.2529890537261963 + }, + { + "check": "check_odd_physical_binding.py", + "seconds": 5.120743989944458 + }, + { + "check": "check_odd_precision.py", + "seconds": 9.233046054840088 + }, + { + "check": "check_odd_partial_admission.py", + "seconds": 9.641279935836792 + }, + { + "check": "check_odd_fixed_tape_counts.py", + "seconds": 0.25513291358947754 + } + ] +} diff --git a/research/p104-main46-original-clear/receipts/clean-native-stage.json b/research/p104-main46-original-clear/receipts/clean-native-stage.json new file mode 100644 index 0000000000..15dd6e7de8 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/clean-native-stage.json @@ -0,0 +1,10 @@ +{ + "bootstrap": false, + "cap_seconds": 480, + "exit": 0, + "finished_utc": "2026-11-17T19:03:36.522047+00:00", + "python": "3.12.14", + "seconds": 257.82616570964456, + "stage": "native", + "started_utc": "2026-11-17T18:59:18.694455+00:00" +} diff --git a/research/p104-main46-original-clear/receipts/clean-signed-stage.json b/research/p104-main46-original-clear/receipts/clean-signed-stage.json new file mode 100644 index 0000000000..3290d1386f --- /dev/null +++ b/research/p104-main46-original-clear/receipts/clean-signed-stage.json @@ -0,0 +1,10 @@ +{ + "bootstrap": false, + "cap_seconds": 480, + "exit": 0, + "finished_utc": "2026-11-17T19:07:47.170908+00:00", + "python": "3.12.14", + "seconds": 250.60494358465075, + "stage": "signed", + "started_utc": "2026-11-17T19:03:36.564357+00:00" +} diff --git a/research/p104-main46-original-clear/receipts/delta.json b/research/p104-main46-original-clear/receipts/delta.json new file mode 100644 index 0000000000..b40ce62f2d --- /dev/null +++ b/research/p104-main46-original-clear/receipts/delta.json @@ -0,0 +1 @@ +{"basis_rows": 9, "candidate_canonical_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", "empty_owned_endpoints": 68, "events": 76646, "last_baseline_clock": 76635, "max_form_terms_on_common_event": 8, "owned_clear_rows": 74, "peer_edits_sha256": "a680a58eab62923443c4e1f401df65d601c5f301a76a7a3d672e85b047444ffb", "public_endpoint_rows": 1501, "seconds_cap": 30, "source_word_sha256": "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd", "status": "PASS_EXACT_NORMALIZED_SCALAR_DIFFERENCE", "zero_COPY_destinations": 1} diff --git a/research/p104-main46-original-clear/receipts/native-stage.json b/research/p104-main46-original-clear/receipts/native-stage.json new file mode 100644 index 0000000000..11994f7027 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/native-stage.json @@ -0,0 +1,10 @@ +{ + "bootstrap": true, + "cap_seconds": 480, + "exit": 0, + "finished_utc": "2026-11-17T18:52:39.381459+00:00", + "python": "3.12.14", + "seconds": 206.45849266648293, + "stage": "native", + "started_utc": "2026-11-17T18:49:12.921612+00:00" +} diff --git a/research/p104-main46-original-clear/receipts/native.log b/research/p104-main46-original-clear/receipts/native.log new file mode 100644 index 0000000000..ff39045262 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/native.log @@ -0,0 +1,24 @@ +PASS authenticated source, complete frame and adjoint checks +PASS complete forward grid, COPY guards and all public/owned endpoints +caller 0 terms 77 +caller 500 terms 621 +caller 1000 terms 2648 +caller 1500 terms 3619 +caller 2000 terms 1590 +caller 2500 terms 398 +caller 3000 terms 1918 +caller 3500 terms 1797 +caller 4000 terms 1817 +caller 4500 terms 912 +caller 5000 terms 167 +PASS complete ingredient invoices, both directed prices, all outer gates and precision +events 76646 public 1501 owned roles 68 paid {1: 3991, 2: 850, 3: 828, 4: 224, 5: 344, 6: 16, 7: 11, 8: 5} owned UP {1: 10, 2: 4, 3: 1, 4: 6, 5: 1, 6: 1} helpers {1: 18, 2: 21, 3: 47, 4: 225, 5: 80, 6: 43, 7: 19, 8: 32, 9: 616} +endpoint bad rows 0 odd certificate S 1125 +PASS_HOST3 decoupled ports 96 hosted ports 8 +gate interpreter agrees with the library on 4 exact state vectors +replayed 76646 events, 2955 chart pairs, 20s +prime 1000000009 seed 11: helper rows bad 0 (of 1101), X rows bad 0, Y rows bad 0, X2 rows bad 0, Y2 rows bad 0 (of 104 ports; 96 with second mains) +tableau on 104 ports: XX!=D 0 YY!=D 0 YX!=Q^-1D 0 XY!=QD 0 | controls matching (must be 0): 0 0 +PASS_PHYSICAL 28s +PASS all affected Gaussian columns and absolute phase, finite physical replay and signed routes +PASS_MAIN46_COMPLETE_NATIVE 0.003649998113545 diff --git a/research/p104-main46-original-clear/receipts/owned.json b/research/p104-main46-original-clear/receipts/owned.json new file mode 100644 index 0000000000..cea5183874 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/owned.json @@ -0,0 +1 @@ +{"basis_rows": 9, "candidate_canonical_sha256": "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916", "empty_owned_endpoints": 68, "events": 76646, "last_baseline_clock": 76635, "max_form_terms_on_common_event": 8, "owned_clear_rows": 74, "owned_interface_row_checks": 1599, "peer_edits_sha256": "a680a58eab62923443c4e1f401df65d601c5f301a76a7a3d672e85b047444ffb", "public_endpoint_rows": 1501, "seconds_cap": 30, "source_word_sha256": "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd", "status": "PASS_EXACT_NORMALIZED_SCALAR_DIFFERENCE", "zero_COPY_destinations": 1} diff --git a/research/p104-main46-original-clear/receipts/r303-finite.time b/research/p104-main46-original-clear/receipts/r303-finite.time new file mode 100644 index 0000000000..88e94ab4f4 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/r303-finite.time @@ -0,0 +1,4 @@ +UNRESOLVED_CAP_AFTER_30_SECONDS +real 30.11 +user 30.06 +sys 0.02 diff --git a/research/p104-main46-original-clear/receipts/r303-first.jsonl b/research/p104-main46-original-clear/receipts/r303-first.jsonl new file mode 100644 index 0000000000..2b7231cb72 --- /dev/null +++ b/research/p104-main46-original-clear/receipts/r303-first.jsonl @@ -0,0 +1 @@ +{"clear44": {"451": "-1", "902": "-3/2", "985": "-3/2", "1495": "1"}, "gross_interval": ["859212856771379242819094339146058521416296730259/10000000000000000000000000000000000000000000000000", "859212856771379242819094339146082028864338851237/10000000000000000000000000000000000000000000000000"], "paid_delta": {"1": -34, "2": 17}, "source_pins": {"7113-CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", "FINAL7605.json": "f24baa73a60d084a6d613dad914f1237a5890a049a183b993af39c75dde99add", "check7610.py": "f6af01c25ea3c841ae80a15dad6d658cf132c4e771796ce849d41dcc8848ed18", "edits7610.json": "a680a58eab62923443c4e1f401df65d601c5f301a76a7a3d672e85b047444ffb", "gate.py": "aa13cd2797877ef7328d5bcda24be51815fddcc4e8ae091382ad963fb978e5e9", "pricing.py": "f4d0b6c9314b838d882d6d06020f24881c19a3fda97a7c00df87b1e920785182", "word7605.json.gz": "37358c493d18ebc6be386aebb4c17529b38883674731f7009ef4e96a5313467d"}, "status": "CLEAR44_MATCH_OTHER_GATES_PENDING"} diff --git a/research/p104-main46-original-clear/receipts/signed-stage.json b/research/p104-main46-original-clear/receipts/signed-stage.json new file mode 100644 index 0000000000..20bf00727e --- /dev/null +++ b/research/p104-main46-original-clear/receipts/signed-stage.json @@ -0,0 +1,10 @@ +{ + "bootstrap": true, + "cap_seconds": 480, + "exit": 0, + "finished_utc": "2026-11-17T18:58:32.610985+00:00", + "python": "3.12.14", + "seconds": 228.0850294996053, + "stage": "signed", + "started_utc": "2026-11-17T18:54:44.524695+00:00" +} diff --git a/research/p104-main46-original-clear/receipts/signed.log b/research/p104-main46-original-clear/receipts/signed.log new file mode 100644 index 0000000000..508a27bccd --- /dev/null +++ b/research/p104-main46-original-clear/receipts/signed.log @@ -0,0 +1,48 @@ +PASS two complete literal invoices and both directed prices 0.003650666180757 +RUN emit_odd_type_b.py +caller 0 terms 41 +caller 500 terms 1178 +caller 1000 terms 2699 +caller 1500 terms 1262 +caller 2000 terms 881 +caller 2500 terms 2484 +caller 3000 terms 765 +caller 3500 terms 640 +caller 0 terms 41 +caller 500 terms 1178 +caller 1000 terms 2701 +caller 1500 terms 1264 +caller 2000 terms 881 +caller 2500 terms 2485 +caller 3000 terms 765 +caller 3500 terms 641 +PASS exact short type B 3877 events Counter({8: 34, 9: 4, 56: 4, 48: 4, 40: 4, 32: 4, 24: 4, 16: 4, 64: 2}) +RUN emit_odd_type_ab.py +caller 0 terms 73 +caller 500 terms 1076 +caller 1000 terms 2476 +caller 1500 terms 1334 +caller 2000 terms 2078 +caller 2500 terms 1235 +caller 3000 terms 2978 +caller 3500 terms 2335 +caller 4000 terms 1046 +caller 4500 terms 299 +PASS exact short A+B 4783 events 3752 ['36506661807577608622666732886141/10000000000000000000000000000000000', '18253330903788804311333366443071/5000000000000000000000000000000000'] +RUN check_odd_caller_exact_grid.py +PASS odd caller grid [381, 69, 62] [381, 3, 2] scale bits 10 checked 176874 +RUN check_odd_physical_binding.py +PASS exact physical binding 110349 13600 22461 +RUN check_odd_precision.py +PASS short precision 406 1215 2430 +RUN check_odd_partial_admission.py +ordinary bill 782685204 +PASS partial signed short gates 782685204 3650666180757/1000000000000000 {'strict_count': 54, 'functional_count': 4, 'minimum_margin': '1/1000000000000000000', 'BIT_just_below_effective_rejected': True} +RUN check_odd_fixed_tape_counts.py +PASS finite tariff substitution 43929184 25448575552 precision 2430 +RUN complete catalogue 0 1000 +RUN complete catalogue 1000 2000 +RUN complete catalogue 2000 3000 +RUN complete catalogue 3000 3040 +PASS complete 8+9 component application checks 3650666180757/1000000000000000 3040 110349 +PASS_MAIN46_COMPLETE_SIGNED_APPLICATION 0.003650666180757 diff --git a/research/p104-main46-original-clear/replay.py b/research/p104-main46-original-clear/replay.py new file mode 100644 index 0000000000..ff7893cf12 --- /dev/null +++ b/research/p104-main46-original-clear/replay.py @@ -0,0 +1,130 @@ +"""Rebuild the pinned main-46 edit and replay its native and signed application.""" +import argparse +from hashlib import sha256 +import json +from pathlib import Path +from shutil import copyfile +import subprocess +import sys + +ROOT = Path(__file__).resolve().parent +RECEIPTS = ROOT / "receipts" +BASE = "e1d2756eecf03e146338239fee81772a99ba8d4c" +SOURCE = "https://github.com/CrocSwap/integer-mult-bounds.git" +PACKAGE = Path("research/p104-timed-helper757") +EDITS = ROOT / "inputs/edits7610.json" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def git(checkout, *arguments): + return subprocess.check_output(["git", "-C", str(checkout), *arguments], timeout=120, text=True).strip() + + +def command(script, *args, timeout=35): + result = subprocess.run([sys.executable, "-I", "-B", str(ROOT / script), *map(str, args)], + capture_output=True, timeout=timeout) + if result.returncode: + sys.stderr.write(result.stderr.decode()) + sys.stderr.write(result.stdout.decode()) + result.check_returncode() + return result.stdout + + +def authenticate_7605(checkout): + require(git(checkout, "rev-parse", "HEAD") == BASE, "Dependency must be exact #7605") + seen = set() + for line in (ROOT / "inputs/7605.sha256").read_text().splitlines(): + digest, name = line.split(" ", 1) + path = Path(name) + require(path.is_relative_to(PACKAGE) and ".." not in path.parts and path not in seen, + f"Ambiguous or duplicate input path {name!r}") + seen.add(path) + source = checkout / path + require(source.is_file() and source.resolve() == source, f"Missing or nonliteral path {name}") + require(sha256(source.read_bytes()).hexdigest() == digest, f"Input hash diverged for {name}") + actual = {p.relative_to(checkout) for p in (checkout / PACKAGE).rglob("*") if p.is_file()} + require(actual == seen and len(seen) == 138, "Expected exact #7605 package closure") + + +def fetch_7605(checkout): + checkout.mkdir() + git(checkout, "init", "-q") + git(checkout, "remote", "add", "source", SOURCE) + git(checkout, "sparse-checkout", "set", "--no-cone", f"/{PACKAGE}/") + git(checkout, "fetch", "-q", "--depth=1", "--filter=blob:none", "source", BASE) + git(checkout, "checkout", "--detach", "-q", BASE) + + +def same_json(actual, expected): + require(json.loads(actual) == json.loads(expected.read_bytes()), f"Replay differs from {expected.name}") + + +def main(): + if sys.version_info[:2] != (3, 12) or not __debug__: + raise ValueError("Use CPython 3.12 with assertions enabled") + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--work", type=Path, required=True, help="a new evidence directory") + parser.add_argument("--source-checkout", type=Path, help="pre-existing exact #7605 checkout") + parser.add_argument("--finite-only", action="store_true", help="stop after exact finite gates") + args = parser.parse_args() + work = args.work.resolve() + work.mkdir() + checkout = args.source_checkout.resolve() if args.source_checkout else work / "source-7605" + if not args.source_checkout: + fetch_7605(checkout) + authenticate_7605(checkout) + src = checkout / PACKAGE + inputs = work / "finite-inputs" + inputs.mkdir() + sources = { + "word.json.gz": src / "data/word.json.gz", + "FINAL.json": src / "data/FINAL.json", + "invoice-new.json": src / "data/invoice-new.json", + "7113-CALLER.json": src / "retained/role902/bench/inputs/7113-CALLER.json", + "pricing.py": ROOT / "checks/pricing.py", + "edits7610.json": EDITS, + } + for name, source in sources.items(): + copyfile(source, inputs / name) + copyfile(inputs / "word.json.gz", inputs / "word7605.json.gz") + candidate = work / "word.json.gz" + emitted = command("checks/emit_main46.py", "--source", inputs / "word.json.gz", "--peer-edits", EDITS, + "--output", candidate) + print(emitted.decode(), end="", flush=True) + exact = command("checks/check_delta.py", "--input-root", inputs, "--candidate", candidate) + same_json(exact, RECEIPTS / "EXACT.json") + print(exact.decode(), end="", flush=True) + phases = command("checks/check_main46_phase.py", "--word", inputs / "word.json.gz", "--engine-root", + src / "retained/role902/independent/engines", "--all-columns", timeout=60) + same_json(phases, RECEIPTS / "PHASE.json") + print(phases.decode(), end="", flush=True) + invoice = command("checks/recount_main46.py", "--baseline", inputs, "--candidate", candidate) + same_json(invoice, RECEIPTS / "INVOICE.json") + (work / "INVOICE.json").write_bytes(invoice) + print("PASS exact finite construction, phase and directed invoice", flush=True) + if args.finite_only: + return + + overlay = work / "overlay" + command("application/prepare_overlay.py", "--source-checkout", checkout, "--overlay", overlay, + "--candidate", candidate, "--peer-edits", EDITS, "--invoice-receipt", work / "INVOICE.json") + main_module = overlay / "application.py" + command("application/patch_native.py", main_module, "--output", overlay / "application-checked.py", + "--receipt", work / "NATIVE-PATCH.json") + (overlay / "application-checked.py").replace(main_module) + for file in ("NATIVE.json", "SIGNED.json", "FINAL.json"): + copyfile(RECEIPTS / file, overlay / "data" / file) + for stage in ("native", "signed"): + print(f"RUN complete {stage} application on the frozen word", flush=True) + print(command("application/run_stage.py", stage, "--overlay", overlay, "--work", work / stage, + timeout=500).decode(), end="", flush=True) + same_json((work / "signed/FINAL.json").read_bytes(), RECEIPTS / "FINAL.json") + print("PASS full main-46 original-CLEAR conditional application") + + +if __name__ == "__main__": + main() diff --git a/research/p104-main46-original-clear/verify.py b/research/p104-main46-original-clear/verify.py new file mode 100644 index 0000000000..4204d58901 --- /dev/null +++ b/research/p104-main46-original-clear/verify.py @@ -0,0 +1,100 @@ +"""Check sealed evidence bindings and the exact signed-invoice price comparison.""" +import argparse +from copy import deepcopy +from fractions import Fraction +from hashlib import sha256 +import json +from pathlib import Path +from runpy import run_path + +ROOT = Path(__file__).resolve().parent +RECEIPTS = ROOT / "receipts" +BASE = "e20f3f9240ac3f5fa4bbd7ab9b5550d660886901bb209f335409c329ac45d9cd" +CANDIDATE = "aa83ede3e5833d43606d711068619db0dc28cbcd858dd11e8e89da6d09883916" +CALLER = "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc" + + +def read(name): + return json.loads((RECEIPTS / name).read_bytes()) + + +def check_manifest(): + seen = set() + for line in (ROOT / "SHA256SUMS").read_text().splitlines(): + digest, name = line.split(" ", 1) + relative = Path(name) + assert not relative.is_absolute() and ".." not in relative.parts and relative not in seen + seen.add(relative) + source = ROOT / relative + assert source.resolve() == source and sha256(source.read_bytes()).hexdigest() == digest, name + actual = {p.relative_to(ROOT) for p in ROOT.rglob("*") if p.is_file() and "__pycache__" not in p.parts} + assert actual == seen | {Path("SHA256SUMS")}, "Complete path-keyed package inventory" + + +def check_paid(before, after): + ranks = set(before) | set(after) + delta = {rank: after.get(rank, 0) - before.get(rank, 0) for rank in ranks + if after.get(rank, 0) != before.get(rank, 0)} + assert delta == {"1": -34, "2": 17} + assert sum(before.values()) == 110366 and sum(after.values()) == 110349 + + +def signed_moment(invoice): + ranks = set(invoice["T"]) | set(invoice["P"]) + return {int(rank): invoice["T"].get(rank, 0) - invoice["P"].get(rank, 0) for rank in ranks} + + +def main(): + assert __debug__ + parser = argparse.ArgumentParser(description=__doc__) + parser.parse_args() + check_manifest() + native, signed, final, baseline = (read(name) for name in ( + "NATIVE.json", "SIGNED.json", "FINAL.json", "7605-replay.json")) + assert native["status"] == "PASS_MAIN46_COMPLETE_NATIVE" + assert signed["status"] == "PASS_MAIN46_COMPLETE_SIGNED_APPLICATION" + assert final["status"] == "PASS_MAIN46_FINAL_APPLICATION" + assert signed["source_head"] == baseline["head"] == "e1d2756eecf03e146338239fee81772a99ba8d4c" + assert signed["component_head"] == "93fded4340bb08bc1f99d6f18e47a198456a41df" + assert baseline["registered_final"]["candidate_canonical_sha256"] == BASE + assert signed["caller_sha256"] == final["caller_sha256"] == baseline["caller"]["sha256"] == CALLER + assert native["word_canonical_sha256"] == final["candidate_canonical_sha256"] == CANDIDATE + exact = read("EXACT.json") + assert exact["candidate_canonical_sha256"] == CANDIDATE and exact["owned_clear_rows"] == 74 + assert exact["owned_interface_row_checks"] == 1599 and exact["public_endpoint_rows"] == 1501 + assert native["charts"]["main46_composed_columns"] == native["charts"]["main46_composed_adjoint_columns"] == 512 + assert all(native["controls"][name] for name in ("missing_main46_paid_move", "wrong_main46_move_source", + "missing_main46_coframe_correction")) + price = signed["price"] + old, new = (price[key] for key in ("before", "after")) + audited = read("INVOICE.json") + assert old["P"] == audited["old_full_paid"] and new["P"] == audited["new_full_paid"] + assert old["T"] == new["T"] == audited["productive_targets"] and sum(new["T"].values()) == 22461 + assert old["S"] == new["S"] == 1424 and not new["empty_root_credits"] + check_paid(old["P"], new["P"]) + mutated = deepcopy(new["P"]) + mutated["2"] -= 1 + try: + check_paid(old["P"], mutated) + except AssertionError: + pass + else: + raise AssertionError("Missing rank-two paid position control was accepted") + + cost = run_path(str(ROOT / "checks/pricing.py"))["cost"] + claim = Fraction(final["framework_claim"]) + old_claim = Fraction(final["comparator_claim"]) + assert claim == Fraction(signed["claim"]) == Fraction("0.003650666180757") + assert old_claim == Fraction(baseline["registered_final"]["framework_claim"]) + assert final["comparator_crossing"] == baseline["registered_final"]["raw_crossing"] + assert claim > Fraction(final["comparator_crossing"][1]) > old_claim + assert cost(signed_moment(old), claim)[1] < 0 < cost(signed_moment(new), claim)[0] + assert claim - old_claim == Fraction("0.000000221936041") + assert final["ordinary_bound"] == audited["ordinary_projected_after"] == 782685204 + assert final["precision_c"] == 2430 and final["tape"]["elementary_records_upper"] == 25448575552 + assert final["signed_physical_map_count"] == 3040 + print("PASS signed invoice price, receipt bindings and missing-paid control") + + +if __name__ == "__main__": + main()