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-finite-monomial-decoder-bound/AUDIT.json b/research/p104-finite-monomial-decoder-bound/AUDIT.json new file mode 100644 index 0000000000..7829059388 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/AUDIT.json @@ -0,0 +1,20 @@ +{ + "audited_baseline_upper": "-350779588127118525082196069/2500000000000000000000000", + "circular_rank_zero_pairs": 1086, + "eligible_groups": 898, + "independent_pairs": 0, + "moves": 6281, + "receipts": { + "GATE.json": "d047446188cd0bb93c5835a536560dc6509e8369e774c017e0f4a63c98cdc61d", + "TYPED.json": "68202ba9326938cb0bf5abbabb893c3db01090a22acb6ba55afaef1dbae2bf9c" + }, + "row_classes": 5189, + "source_pins": { + "deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "deps/round11/frontier/independent_adapter_price.py": "2a46157d156bdfc0e892289005fd3fb7c23708de48c9abd90c1914b0372bc726", + "inputs/native/RESULT.json": "75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49", + "inputs/native/WORD.json.gz": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + "status": "PASS_INDEPENDENT_PROJECTIVE_AND_TYPED_AVAILABILITY", + "tested_pairs": 2602 +} diff --git a/research/p104-finite-monomial-decoder-bound/CAP-ONE.json b/research/p104-finite-monomial-decoder-bound/CAP-ONE.json new file mode 100644 index 0000000000..3f6a9096c4 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/CAP-ONE.json @@ -0,0 +1,65 @@ +{ + "baseline": [ + "-701559176254237050164412023/5000000000000000000000000", + "-1403118352508474100328768149/10000000000000000000000000" + ], + "cap": { + "moves": 1, + "seconds": 480 + }, + "complete_saving_interval": [ + "1865549583978250671307771075621/10000000000000000000000000", + "1865549583978250671307771114381/10000000000000000000000000" + ], + "controls": { + "cheapest_retained_charged": true, + "one_coefficient_corruption_splits_group": true, + "signed_proportional": true + }, + "eligible_group_details": [], + "eligible_groups": 0, + "eligible_member_hist": {}, + "eligible_members": 0, + "input_pins": { + "deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "deps/round13/alternative/reprice.py": "97f4524d11a08cd3a09ceb9abc6b90f45ca579ac1c529a176b80a67201ecd90a", + "deps/round20/complex-stock/stock.py": "8a1968502614a3c2fe90699460e9d7f8d4667fa9072b2947c53f430a0efab49e", + "inputs/caller/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "inputs/native/RESULT.json": "75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49", + "inputs/native/WORD.json.gz": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + "moves_checked": 1, + "moves_pending": 6280, + "nonzero_repeated_groups": 0, + "original_paid_positions": 110553, + "original_productive_targets": 22461, + "pending_full_credit_hist": { + "1": 4000, + "2": 853, + "3": 829, + "4": 225, + "5": 344, + "6": 14, + "7": 10, + "8": 5 + }, + "per_stage_saving_interval": [ + "109738210822250039488692416213/10000000000000000000000000", + "109738210822250039488692418493/10000000000000000000000000" + ], + "raw_margin_upper": "233018308203217774650930293279/1250000000000000000000000", + "repeated_same_target_only_groups": 0, + "retained_hist": {}, + "row_groups": 1, + "scope": "One retained original child per exact proportional row group and distinct target cosets; free typed outputs.", + "site_tests": 0, + "skipped_child_hist": {}, + "source_head": "4156504fa39efb51c550d218a9b94fe69dbce8f6", + "source_tree": "f201bc8b5d1402ca40e7aa419269a58b7724798d", + "stages": 17, + "status": "POSITIVE_OPTIMISTIC_STOCK", + "stop_reason": "MOVE cap", + "target": "10018846261809/2500000000000000", + "target_cosets": 1, + "zero_row_events": [] +} diff --git a/research/p104-finite-monomial-decoder-bound/FINITE-ARMS.md b/research/p104-finite-monomial-decoder-bound/FINITE-ARMS.md new file mode 100644 index 0000000000..8c054cad96 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/FINITE-ARMS.md @@ -0,0 +1,72 @@ +# A finite monomial decoder cannot mix these three chart bases + +Fix exact #7244 scientific head `4156504fa39efb51c550d218a9b94fe69dbce8f6`, +its unchanged scientific tree `f201bc8b5d1402ca40e7aa419269a58b7724798d` +at live head `215f67247f395c0e15f5ea3980f6a3e4aed155af`, and exact +#7113 caller `07a76c5e2738882c0cb322278e56f6cae3c9885d`. The comparator +is κ = 0.003645372367832. Work at the fixed target +10018846261809/2500000000000000. + +## Declared decoder and tensor obstruction + +Use one exact projective normalized input row. A retained old paid MOVE +has source chart F and returned chart G. An omitted target uses chart H +and the same arbitrary input. Permit a fixed finite number of ordinary +left monomial terms on each of the source and returned arrays, with +arbitrary coefficients and permutations. This grants every row its own +coefficients and arbitrary selected coordinates. Exact old scalar chronology, +single independently available resident source, and next-touch output +deadlines are retained. Price every new ordinary term at zero in the upper. + +The inherited application premise is that at column multiplicity f, +the physical field is represented by the f-fold chart tensor on arbitrary +full arrays. See [the exact application review](contracts/canonical-PROOF-REVIEW.md). +Global scalings and phases of the chart bases can be normalized or +absorbed into coefficients. After normalization a Clifford transition of +active rank r has entry magnitudes 0 or 2^(−r/2) at one column. Distinct +ordinary monomial cosets have r ≥ 1. The maximum row overlap between +the bases at multiplicity f is then at most μ = 2^(−f/2). + +Suppose F, G and H are pairwise distinct cosets. A requested H row +would need to lie in the span of a rows of the F basis and b rows of the +G basis, after deleting duplicate rows within each basis. Rows within +each basis are orthonormal, so the selected Gram matrix has diagonal +identity blocks. Its cross block has operator norm at most √(ab) μ +by the Frobenius bound. Its smallest eigenvalue is at least +1−√(ab) μ. The squared norm of the requested row's overlaps with all +selected rows is at most (a+b) μ². When the Gram lower bound is +positive, the squared norm of its orthogonal projection on the selected +span is therefore at most + +```text +(a+b) μ² / (1−√(ab) μ). +``` + +For every finite arm count independent of f this tends to zero. Take f +large enough that it is below one. The requested unit row cannot be +represented. This argument allows arbitrary coefficients and also works +when one basis contributes zero terms. With one source arm and two +returned arms, already f = 3 gives the projection upper 3/4. + +## Stock and price + +The 6,281 exact native paid MOVEs produce 898 projective input classes +with distinct target cosets. Among the 2,602 ordered retained/omitted +choices, 1,516 have three distinct cosets. The tensor argument excludes +all of them. The remaining 1,086 are monomial-source cases. Every apparent +resident usable before the original deadline needs the omitted output +itself. No distinct pair has identical returned and target cosets. + +At width one, the two-returned-arm support condition grants 685 distinct +clock-feasible ordered choices and an optimistic positive price. These +all have three distinct cosets and fail the necessary all-column test. +All 2,602 choices exhausted. Granting every other original paid child +to each independent-source check still gives zero certified compatible +omissions. The complete signed upper is +−1403118352508474100328768149/10^25 at the target across all 17 stages. +There is no κ gain. + +The replay pins the two independent Clifford interpretations and the +complete source chronology. Neither a changed child on several source +lanes nor a decoder with a growing arm count is covered. No new native, +tape, complete multiplier or maintainer admission is asserted. diff --git a/research/p104-finite-monomial-decoder-bound/LICENSE b/research/p104-finite-monomial-decoder-bound/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/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-finite-monomial-decoder-bound/NOTICE b/research/p104-finite-monomial-decoder-bound/NOTICE new file mode 100644 index 0000000000..b198912d3f --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/NOTICE @@ -0,0 +1,20 @@ +This scoped typed source-availability calculation and packaging are Apache-2.0. +OpenAI Codex and subagents materially assisted the derivation and replay audit. + +The exact native word and result are from Clear1nsight #7244, scientific commit +4156504fa39efb51c550d218a9b94fe69dbce8f6 and scientific package tree +f201bc8b5d1402ca40e7aa419269a58b7724798d. Live head 215f67247f395c0e15f5ea3980f6a3e4aed155af +carries the same scientific tree. The original source notice is preserved in +NOTICE-7244. Clear1nsight #7161 supplied the prior funded native construction. + +The exact signed caller is Rohan Arun #7113's expected/ODD-TYPE-AB-CALLER.json +at commit 07a76c5e2738882c0cb322278e56f6cae3c9885d. Its Apache-2.0 license is +included as LICENSE. + +The exact Clifford compiler and independent interpreter are from the canonical +shared-wire-split-composition package. The original notice is preserved unchanged +in NOTICE-CLIFFORD. The Round 20 fixed-output stock helpers are also present in +#7245. The Round 13 primary directed price reader and Round 11 independent price +engine are also present in #7243. The present work adds the exact projective +input classes, returned-arm support gate, and independent source availability +audit under the old #7244 scalar trace and deadlines. diff --git a/research/p104-finite-monomial-decoder-bound/NOTICE-7244 b/research/p104-finite-monomial-decoder-bound/NOTICE-7244 new file mode 100644 index 0000000000..c31402a4fb --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/NOTICE-7244 @@ -0,0 +1,13 @@ +Prepared for Clear1nsight with substantial OpenAI Codex and ChatGPT Pro +assistance. New work is Apache-2.0. + +ChatGPT Pro identified the symmetric and antisymmetric two-cut mechanism. +OpenAI Codex independently reconstructed the exact timed witness, emitted +the literal candidate, and adapted and executed the source-bound checks. +Credit the exact #7161 funded exit and #7164 application review, Rohan +Arun's #7156 and #7113, Ali Romman's causal-history owned-buffer identity, +Jerry Chen / CubeJerry's timing and exact replay, Matarener's kernels, +dillona's temporal constructor, and ToikY's exact pricing engines. The +selected framework retains the #7000/#7001 contributor and maintainer +credit. Source licenses and predecessor notices remain in the archive +and reference directory. diff --git a/research/p104-finite-monomial-decoder-bound/NOTICE-CLIFFORD b/research/p104-finite-monomial-decoder-bound/NOTICE-CLIFFORD new file mode 100644 index 0000000000..a3687d65a0 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/NOTICE-CLIFFORD @@ -0,0 +1,9 @@ +New shared-wire composition, seventeenth wire, and two enabling splits: developed with substantial OpenAI assistance, 2026. Apache-2.0. + +Frozen predecessor native words and odd verifier: DreamingOfClouds, with Claude Opus 5.5 (Anthropic), from #6936 and #6937. + +Retained Clifford compiler and exact native interpreter retain their original headers and lineage from #6833: native source by DreamingOfClouds; independent-helper mechanism by Ali Romman; inventory, retiming and helper-retirement extensions by Jerry Chen / @CubeJerry with OpenAI assistance. + +Helper-split lemma: Ali Romman (#5599). Shared native applications: CubeJerry (#6916). Caller blocks: CubeJerry (#6912). Owned-rise argument: CubeJerry (#6914). Width-2 phase convention: unpaidmoon (#6930). Odd-grid precedent: icekylinx (#104). + +The higher-level caller and BIT integration require their own source attribution and pins. diff --git a/research/p104-finite-monomial-decoder-bound/PROOF.md b/research/p104-finite-monomial-decoder-bound/PROOF.md new file mode 100644 index 0000000000..585da7ad1f --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/PROOF.md @@ -0,0 +1,51 @@ +# One-input typed MOVE decoder stock on #7244 + +**NO VERIFIED GAIN.** This is an independently audited stock result on the exact #7244 native word and unchanged #7113 signed caller. Its new scoped decoder family saves **0 per stage and 0 across 17 stages** at the fixed moonshot target κ* = 10018846261809/2500000000000000. The directed raw upper is exactly −1403118352508474100328768149/10^25, approximately **−140.31183525084741**. The complete #7244 claim of κ = 0.003645372367832 has its own separate application replay. This stock result independently reconstructs its 110,553 paid positions and 22,461 productive targets. It does not settle the complete outer claim. [#7244 exact science](https://github.com/CrocSwap/integer-mult-bounds/tree/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split), [#7113 signed caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) + +## Exact stock and deliberately free outputs + +The 6,281 old native MOVEs are partitioned by exact proportional normalized incoming rows on 1,501 arbitrary public inputs. Rows are compared in canonical rational projective form, with signs allowed. The independently replayed scalar state checks original COPY destination zero. Each output chart is put in its exact monomial coset by canonicalizing the binary Pauli subspace (T_F^{-1} Z T_F), where (Z) is the diagonal Pauli subspace. There are 5,189 projective input classes and 978 target cosets. Exactly 898 input classes have multiple target cosets, with 1,990 positions and sizes two, three and four in 719, 164 and 15 classes. All old input rows are nonzero. + +Retain the cheapest old child once per eligible input class. Grant every other typed output, route, clock, setup, ownership operation, restoration, precision and tape charge free. The classes are disjoint in original occurrence, so this assigns each of the 1,092 omitted positions once. The removed rank counts from one through six are 540, 252, 132, 91, 71 and 6. With (H_r=r^{1-κ_*}), the directed credit upper is about 2,187.30572 per native invocation and 37,184.19723 across the signed 17 stages. That idealized margin is **+37,043.88539453012**. It grants the typed outputs outright and establishes only that the unconstrained price inventory is ample. + +## Fixed two-arm decoder and source availability + +For each choice of a retained original paid MOVE from chart F to G, let (x=T_F z) be its one arbitrary complete input and (y=T_G z) its completed output. An omitted target H may decode via (a Mx+b Ny), where M and N are ordinary left monomial adapters and the scalar coefficients are arbitrary. Grant copies and indefinite holding. Keep the old scalar trace and original next-touch deadlines. The retained source can be any single literal resident, on any original owner, in the same source monomial coset with the exact same projective row. Additional source gathers from several independent resident rows, a different old input map, a newly produced earlier source, or multiple monomials on a returned arm change this scope. + +At one positive column multiplicity, the quotient (T_H T_F^{-1}) has exactly (2^s) nonzeros per row. Its row support is an affine coset of the span of X components in the pullback of the diagonal Pauli generators. The corresponding retained rank-r quotient has (2^r) nonzeros. A left monomial preserves its row-support direction, and the source arm supplies at most one additional coordinate. For a nonzero target rank s, the only possible cardinality is s=r. For r≥2, changing one point cannot halve support, and one point cannot double support for any positive r. When cardinality is equal, the support direction must also agree because one point cannot simultaneously delete and replace a coordinate. Rank zero may use the source arm alone. Failure at this finite width rules out an all-width decoder of the stated form. + +Exhaust all 2,602 ordered retained/omitted choices. No pair passes with the retained MOVE in its original contact epoch. The larger relaxation with any old resident and arbitrary holding appears to pass 1,086 choices in 893 classes and grants margin **+25,340.35897815638** with one retained child per class. All 1,086 cases have rank zero and their earliest apparent source is exactly the omitted MOVE's own returned role, at the next cut. That source would disappear with the payment. + +Check availability after suppressing that returned field. For an omitted event d, the role has no old touch until its recorded next mandatory contact. Until that next cut, any earlier observation on the same role through cut d is independent of d, and any observation on a different role is independent of that omitted physical result in the retained tape. Observe every initial and changed state in every role. Allow all these independent observations, including an unlimited copy/holding lifetime and arbitrary ordinary source-coset conversion. Exclude only the deleted output resident after d. None of the 1,086 apparent survivors has an independent qualifying observation by its deadline. The directed saving upper remains zero even with a union over multiple possible retained children. This availability test grants other old paid results even when a concurrent deletion would remove them, so overlap can only reduce feasibility. + +The primary source census exhausted 6,281/6,281 MOVEs. The support census exhausted 2,602/2,602 ordered pairs, including all 1,086 independence checks. Neither hit the time cap and neither leaves a pending case. No site, new child or literal candidate was built. The independent audit uses primitive integer projective rows, the separate exact Clifford interpreter and a new forward state and deadline traversal. It reproduces every class and the circular-source obstruction, plus the negative baseline using separate rational price bounds. The cap-one control preserves 6,280 unseen events at their full ideal price and is inconclusive. A changed caller byte is rejected by its SHA-256 pin. Hosted checks were unrun for this scoped experiment. + +## Next bounded decision + +If retaining this cost lever, add one more ordinary returned-arm monomial while keeping the source independent. Price all 2,602 existing ordered pairs with a three-minute cap before any site. If D is the retained row-support direction and E the target direction, two returned terms can cover at most two affine D cosets. The optional single source point cannot cover the two or more remaining fibers when the quotient image of E has dimension at least two. Thus \(\dim(E/(E\cap D))\leq1\) is a necessary width-one gate. Recompute independent source availability and deduplicate the original paid positions. Stop if the directed upper fails to cover 140.31183525084741 or the budget leaves no bounded next test. Only a positive comparable stock and credible BIT path justify one full signed decoder and ownership proof. This next gate remains unrun. + +## Exact-source overlap + +The scientific commit is `4156504fa39efb51c550d218a9b94fe69dbce8f6`. The live #7244 head `215f67247f395c0e15f5ea3980f6a3e4aed155af` carries the same scientific package tree `f201bc8b5d1402ca40e7aa419269a58b7724798d`. Both exact public heads identify the same native word and invoice Git blobs. #7244 pays two new exits to admit two causal retirements. The present gate keeps that already constructed paid word and asks whether one retained old result and one genuinely available source arm can serve omitted outputs. [Exact #7244 construction](https://github.com/CrocSwap/integer-mult-bounds/blob/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split/PROOF.md) + +#7243 bounds split payloads between different canonical charts over existing paid descents in the older #7161 word. #7245 studies fixed whole-output reconstruction within target monomial cosets on #7161. Here each eligible group has one exact projective input and distinct target cosets on #7244. The key test is whether the apparently usable source still exists when the omitted payment is removed. The exact earlier proofs supply related boundaries and reusable code. [#7243 ordered cut](https://github.com/CrocSwap/integer-mult-bounds/blob/86951dea757a64ff16b7ca76cb21a5b4eea0b791/research/p104-paid-cross-chart-stock/ORDERED-PROOF.md) · [#7245 fixed-output proof](https://github.com/CrocSwap/integer-mult-bounds/blob/f44e016fa4cfaca0fd52f46a19f650c7a878aef2/research/p104-fixed-output-consolidation/PROOF.md) + +## Clean replay and credit + +Use CPython 3.12 with assertions, tested on 3.12.14. Run from this package directory: + +```sh +python3.12 -I -B replay.py --controls +``` + +The command accepts explicit `--inputs` and `--deps` roots and defaults to the bundled exact files. It authenticates all scientific paths, regenerates the complete TYPED and GATE receipts, checks their original byte lengths and SHA-256s, compares the compact [summary](SUMMARY.json), then compares the independent [audit](AUDIT.json) byte for byte. The full row receipts are generated on demand. The optional controls reproduce [CAP-ONE.json](CAP-ONE.json), with all 6,280 unchecked events still granted ideal credit, and forge one of the circular observations as an independent source. The independent scientific audit rejects that forged survivor. [Exact source and helper pins](SOURCES.tsv) · [Replay manifest](REPLAY.sha256) + +To retain the full regenerated outputs for inspection, use an isolated directory with the same `inputs/`, `deps/` and three scientific script paths: + +```sh +python3.12 -I -B typed_stock.py . --cap 6281 --seconds 480 > TYPED.json +python3.12 -I -B decode_gate.py . --seconds 180 > GATE.json +python3.12 -I -B audit.py . +``` + +Clear1nsight #7244 supplied the exact two-cut funded word and scientific receipt, #7161 supplied the prior funded construction, and Rohan Arun #7113 supplied the signed caller. Round 20 and #7245 supplied the exact frame and MOVE inventory and the target monomial criterion. The canonical compiler and independent Clifford interpreter provide separate operator representations. Round 13 supplied the primary directed price decoder and Round 11 the independent directed price enclosure, preserved in #7243. [Original notices](NOTICE) · [#7244 notice](NOTICE-7244) · [Canonical Clifford notice](NOTICE-CLIFFORD). OpenAI Codex and subagents materially assisted. diff --git a/research/p104-finite-monomial-decoder-bound/README.md b/research/p104-finite-monomial-decoder-bound/README.md new file mode 100644 index 0000000000..6e58553af3 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/README.md @@ -0,0 +1,40 @@ +# Bound finite monomial decoder reuse on #7244 + +**NO VERIFIED GAIN. The κ change is 0%.** On exact #7244, one retained old paid +child acting on one exact projective input cannot supply a cross-coset omitted +MOVE via a fixed finite number of source and returned monomial arms. This holds +under the inherited all-column tensor semantics. The 6,281-MOVE census and all +2,602 ordered choices exhaust the declared inventory. All 1,086 monomial-source +bypasses depend on the omitted MOVE. The whole 17-stage saving is zero. + +[Finite-arm proof](FINITE-ARMS.md) · [One-returned-arm predecessor](PROOF.md) + +## Clean replay + +Use CPython 3.12 with assertions from a clean repository checkout. + +```sh +python3.12 -B scripts/research_package.py --package research/p104-finite-monomial-decoder-bound +``` + +The command uses bundled exact public source bytes and path-keyed pins, with +no network or previous temporary state. It regenerates the full scientific +receipts, verifies their SHA-256 values and checks independent audits. The +standalone replay also accepts explicit input and dependency roots. + +## Open next questions + +A changed child may take multiple independently available input lanes or +use a different charged operation. State its complete typed contract, then +price the stock of distinct eligible old jobs and ownership/restoration before +building one candidate. A changed scalar chronology, unavailable source +synthesis and an arm count growing with multiplicity are separate mechanisms. + +## Credit + +Clear1nsight #7244 supplied the two-cut native, #7161 its predecessor and +Rohan Arun #7113 the signed caller. Credit #7243/#7245 and the canonical +Clifford implementations for the paid, chart and coefficient inventory, +and earlier #7111 work for exact pricing and the original deadline screen. +OpenAI Codex and subagents materially assisted. [Notices](NOTICE) · +[Apache-2.0](LICENSE) diff --git a/research/p104-finite-monomial-decoder-bound/REPLAY.sha256 b/research/p104-finite-monomial-decoder-bound/REPLAY.sha256 new file mode 100644 index 0000000000..6934c1fa5b --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/REPLAY.sha256 @@ -0,0 +1,21 @@ +d8c1f23d79bbad87aac881e56cb038d3bc84c9a6c9834b3abd5a13adca651acf AUDIT.json +8a763983ccc9dbfd58620da2f06aec32c13cda94e74e6f951f79e06da028cb65 CAP-ONE.json +044f3cb4253bd71af45325b686359b122c369cfacd112e6c0c58e558d4cb6cd7 SUMMARY.json +332d2e331d7b5b2e67ee15fc8444853fe2e4470bdafae1cd03eb06e4cb8f3f76 TWO-ARM-AUDIT.json +7270c06773d17a0d5ac80dd17e53eca076a5dfe92a87659ea345845fb594dc61 audit.py +11e649ff994ae44b3bc1c8b5ce498d9f59449c82b139351e07e68ac3f0ddefd1 audit_two_arm.py +d9cc72480f7fd7d7cdcac3d8617b91c39d0630f5dc36a67fb6c2dbf81377bbc0 contracts/PROOF.md +ac7b4473035af648d6073e78b6c39675e706e8194b346bb55ed62a0adc81d593 contracts/SOURCES.json +4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055 contracts/canonical-PROOF-REVIEW.md +acbebef2405e98ec83e3013342167aaa7c06540e491a346cd2ed53ee3359c5e5 contracts/pr7161-PROOF.md +dc0fcc441e6c64797168acea834f42e6ff7c46dee8afdc9ac59d5fd4239f491c decode_gate.py +2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py +3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py +2a46157d156bdfc0e892289005fd3fb7c23708de48c9abd90c1914b0372bc726 deps/round11/frontier/independent_adapter_price.py +97f4524d11a08cd3a09ceb9abc6b90f45ca579ac1c529a176b80a67201ecd90a deps/round13/alternative/reprice.py +8a1968502614a3c2fe90699460e9d7f8d4667fa9072b2947c53f430a0efab49e deps/round20/complex-stock/stock.py +255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc inputs/caller/CALLER.json +75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49 inputs/native/RESULT.json +75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f inputs/native/WORD.json.gz +94f1e961b9883ff6d389f8846ab47fe0c584118f6b7eb94fdea2da5bcaacf5ef two_arm_gate.py +85564000a1a1a54f46af4e2c7091351f918886f7e0868343c9518f7ef9a518f3 typed_stock.py diff --git a/research/p104-finite-monomial-decoder-bound/SOURCES.json b/research/p104-finite-monomial-decoder-bound/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/p104-finite-monomial-decoder-bound/SOURCES.tsv b/research/p104-finite-monomial-decoder-bound/SOURCES.tsv new file mode 100644 index 0000000000..6e1e828c46 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/SOURCES.tsv @@ -0,0 +1,15 @@ +inputs/native/WORD.json.gz 75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f 836f915b721e0716d4d0400cb55741b737102196 https://github.com/CrocSwap/integer-mult-bounds/blob/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split/WORD.json.gz +inputs/native/RESULT.json 75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49 b1d7b3d4a2338b57992acfc1972fe788582e9f8d https://github.com/CrocSwap/integer-mult-bounds/blob/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split/RESULT.json +inputs/caller/CALLER.json 255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc 9451ceaf6e8e037894680b549f3ef41c21b260d7 https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/expected/ODD-TYPE-AB-CALLER.json +deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py 2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962 166841a037f069249f6f7f6dedb89248812f59e2 https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/research/shared-wire-split-composition/frozen/clifford_exact.py +deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py 3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38 2c209dfa9cfade3bc20ac5fc9d876b433a147f8c https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/research/shared-wire-split-composition/frozen/native_verify.py +deps/round20/complex-stock/stock.py 8a1968502614a3c2fe90699460e9d7f8d4667fa9072b2947c53f430a0efab49e db36d1043b8b99a823333408d78a7b6b5b1089ce https://github.com/CrocSwap/integer-mult-bounds/blob/f44e016fa4cfaca0fd52f46a19f650c7a878aef2/research/p104-fixed-output-consolidation/stock.py +deps/round13/alternative/reprice.py 97f4524d11a08cd3a09ceb9abc6b90f45ca579ac1c529a176b80a67201ecd90a bbba640a1a17c92a336be0fa04ea45fa74538320 https://github.com/CrocSwap/integer-mult-bounds/blob/86951dea757a64ff16b7ca76cb21a5b4eea0b791/research/p104-paid-cross-chart-stock/deps/round13/alternative/reprice.py +deps/round11/frontier/independent_adapter_price.py 2a46157d156bdfc0e892289005fd3fb7c23708de48c9abd90c1914b0372bc726 a1a291ac064d0547146063f09330a5bc836fa89b https://github.com/CrocSwap/integer-mult-bounds/blob/86951dea757a64ff16b7ca76cb21a5b4eea0b791/research/p104-paid-cross-chart-stock/deps/round11/frontier/independent_adapter_price.py +NOTICE-7244 3ed23f5fea64744747b3f03d85bcddee18a6fd52611733f34096c200547a2c8b c31402a4fb56f7e334722dd8cdc5313eaa104cfd https://github.com/CrocSwap/integer-mult-bounds/blob/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split/NOTICE +NOTICE-CLIFFORD da12736e2e824167ff56f2ecb623a5f88f75a270410360890f61dffc33bab249 a3687d65a00794277cdaad37558d24008cbc37f5 https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/research/shared-wire-split-composition/NOTICE +LICENSE c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4 261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 https://github.com/CrocSwap/integer-mult-bounds/blob/07a76c5e2738882c0cb322278e56f6cae3c9885d/research/signed-caller-8x9/LICENSE +contracts/PROOF.md d9cc72480f7fd7d7cdcac3d8617b91c39d0630f5dc36a67fb6c2dbf81377bbc0 fcda156f898e1c44f20c385cee0460c64247093e https://github.com/CrocSwap/integer-mult-bounds/blob/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split/PROOF.md +contracts/SOURCES.json ac7b4473035af648d6073e78b6c39675e706e8194b346bb55ed62a0adc81d593 6b97e903a6df8de437068a0e2907823885928053 https://github.com/CrocSwap/integer-mult-bounds/blob/4156504fa39efb51c550d218a9b94fe69dbce8f6/research/p104-two-cut-funded-split/SOURCES.json +contracts/canonical-PROOF-REVIEW.md 4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055 3dd1af2285e597676725e85ad4f65e7ad326d695 https://github.com/CrocSwap/integer-mult-bounds/blob/e54523517d0f03e58352e647c403a5af3e525a57/docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md +contracts/pr7161-PROOF.md acbebef2405e98ec83e3013342167aaa7c06540e491a346cd2ed53ee3359c5e5 0e20dca0d4b5c76bfabd00b36b508f707b5b3860 https://github.com/CrocSwap/integer-mult-bounds/blob/e3f8d39c43b07063dfc5b800f71c5d21015259e6/research/p104-rank8-exit-funded-split/PROOF.md diff --git a/research/p104-finite-monomial-decoder-bound/SUMMARY.json b/research/p104-finite-monomial-decoder-bound/SUMMARY.json new file mode 100644 index 0000000000..a9351d6fff --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/SUMMARY.json @@ -0,0 +1,218 @@ +{ + "receipts": { + "GATE.json": { + "bytes": 465446, + "sha256": "d047446188cd0bb93c5835a536560dc6509e8369e774c017e0f4a63c98cdc61d" + }, + "TYPED.json": { + "bytes": 4875219, + "sha256": "68202ba9326938cb0bf5abbabb893c3db01090a22acb6ba55afaef1dbae2bf9c" + } + }, + "source_availability": { + "completed_groups": 898, + "controls": { + "different_equal_size_direction_rejected": true, + "larger_support_rejected": true, + "one_point_cannot_halve_rank_three": true, + "zero_rank_source_bypass_allowed": true + }, + "eligible_groups_by_mode": { + "support_any_original_resident": 893, + "support_independent_original_resident": 0, + "support_literal_window": 0, + "support_no_clock": 893 + }, + "head": "4156504fa39efb51c550d218a9b94fe69dbce8f6", + "max_seconds": 180, + "passed_by_mode": { + "support_any_original_resident": 1086, + "support_no_clock": 1086 + }, + "pending_groups": 0, + "pending_ideal_hist": {}, + "price_one_retained": { + "support_any_original_resident": { + "caller_interval": [ + "127403354067036139684897719049/5000000000000000000000000", + "254806708134072279369795443521/10000000000000000000000000" + ], + "raw_margin_upper": "63350897445390951317366668843/2500000000000000000000000", + "saving_hist": { + "1": 574, + "2": 127, + "3": 105, + "4": 76, + "5": 10, + "6": 1 + }, + "stage_interval": [ + "7494314945119772922641042297/5000000000000000000000000", + "14988629890239545845282084913/10000000000000000000000000" + ] + }, + "support_independent_original_resident": { + "caller_interval": [ + "0", + "0" + ], + "raw_margin_upper": "-1403118352508474100328768149/10000000000000000000000000", + "saving_hist": {}, + "stage_interval": [ + "0", + "0" + ] + }, + "support_literal_window": { + "caller_interval": [ + "0", + "0" + ], + "raw_margin_upper": "-1403118352508474100328768149/10000000000000000000000000", + "saving_hist": {}, + "stage_interval": [ + "0", + "0" + ] + }, + "support_no_clock": { + "caller_interval": [ + "127403354067036139684897719049/5000000000000000000000000", + "254806708134072279369795443521/10000000000000000000000000" + ], + "raw_margin_upper": "63350897445390951317366668843/2500000000000000000000000", + "saving_hist": { + "1": 574, + "2": 127, + "3": 105, + "4": 76, + "5": 10, + "6": 1 + }, + "stage_interval": [ + "7494314945119772922641042297/5000000000000000000000000", + "14988629890239545845282084913/10000000000000000000000000" + ] + } + }, + "price_overgrant_multiple_retained": { + "support_any_original_resident": { + "caller_interval": [ + "300971845418256622867926210299/10000000000000000000000000", + "37621480677282077858490777131/1250000000000000000000000" + ], + "raw_margin_upper": "299568727065748148767597448899/10000000000000000000000000", + "saving_hist": { + "1": 689, + "2": 204, + "3": 106, + "4": 76, + "5": 10, + "6": 1 + }, + "stage_interval": [ + "17704226201073918992230953547/10000000000000000000000000", + "2213028275134239874028869243/1250000000000000000000000" + ] + }, + "support_independent_original_resident": { + "caller_interval": [ + "0", + "0" + ], + "raw_margin_upper": "-1403118352508474100328768149/10000000000000000000000000", + "saving_hist": {}, + "stage_interval": [ + "0", + "0" + ] + }, + "support_literal_window": { + "caller_interval": [ + "0", + "0" + ], + "raw_margin_upper": "-1403118352508474100328768149/10000000000000000000000000", + "saving_hist": {}, + "stage_interval": [ + "0", + "0" + ] + }, + "support_no_clock": { + "caller_interval": [ + "300971845418256622867926210299/10000000000000000000000000", + "37621480677282077858490777131/1250000000000000000000000" + ], + "raw_margin_upper": "299568727065748148767597448899/10000000000000000000000000", + "saving_hist": { + "1": 689, + "2": 204, + "3": 106, + "4": 76, + "5": 10, + "6": 1 + }, + "stage_interval": [ + "17704226201073918992230953547/10000000000000000000000000", + "2213028275134239874028869243/1250000000000000000000000" + ] + } + }, + "scope": "One source monomial plus one monomial of one completed old paid child per removed target, same exact projective input, old scalar tape, original target deadlines, and no reuse of the removed physical output as an independently available source.", + "site_tests": 0, + "status": "NEGATIVE_FIXED_ONE_MONOMIAL_PER_ARM_UPPER", + "stop_reason": "ordered pair scope exhausted", + "target": "10018846261809/2500000000000000", + "tested_pairs": 2602, + "total_pairs": 2602 + }, + "survivor_counts": { + "support_any_original_resident": 1086, + "support_independent_original_resident": 0, + "support_literal_window": 0, + "support_no_clock": 1086 + }, + "typed_stock": { + "baseline": [ + "-701559176254237050164412023/5000000000000000000000000", + "-1403118352508474100328768149/10000000000000000000000000" + ], + "cap": { + "moves": 6281, + "seconds": 480 + }, + "complete_saving_interval": [ + "185920986148904871083137909993/5000000000000000000000000", + "37184197229780974216627582937/1000000000000000000000000" + ], + "eligible_groups": 898, + "eligible_member_hist": { + "2": 719, + "3": 164, + "4": 15 + }, + "eligible_members": 1990, + "moves_checked": 6281, + "moves_pending": 0, + "original_paid_positions": 110553, + "original_productive_targets": 22461, + "raw_margin_upper": "370438853945301268065947061221/10000000000000000000000000", + "row_groups": 5189, + "skipped_child_hist": { + "1": 540, + "2": 252, + "3": 132, + "4": 91, + "5": 71, + "6": 6 + }, + "source_head": "4156504fa39efb51c550d218a9b94fe69dbce8f6", + "source_tree": "f201bc8b5d1402ca40e7aa419269a58b7724798d", + "stages": 17, + "status": "POSITIVE_OPTIMISTIC_STOCK", + "stop_reason": "literal scope exhausted", + "target": "10018846261809/2500000000000000", + "target_cosets": 978 + } +} diff --git a/research/p104-finite-monomial-decoder-bound/TASK.json b/research/p104-finite-monomial-decoder-bound/TASK.json new file mode 100644 index 0000000000..d949038ec3 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/TASK.json @@ -0,0 +1,117 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Exact #7244 and #7113 typed decoder. One old retained child on one exact projective input lane, using a fixed finite number of ordinary monomial arms on the source and returned fields under the inherited tensor lift.", + "scope_change_reason": "Cross-coset reuse has large unpriced stock. Test exact source deadlines and prove the all-column row-span obstruction before any physical prototype.", + "bottleneck_link": "Fixed finite monomial reuse has zero compatible savings even with free clocks, copying and all ordinary overhead.", + "budget_minutes": 12, + "stop_rule": "Census all 6,281 paid MOVEs and 2,602 ordered pairs or stop at cap with pending pairs priced ideally. Then check the independent source and tensor coherence conditions on the same frozen pairs.", + "outcome": "negative-result", + "evidence": "Exact signed invoice and projective incoming rows, independent source chronology, tensor row coherence and independently reconstructed receipt.", + "author": "ToikY", + "ai_assistance": "OpenAI Codex and subagents materially assisted the proof, verifier and independent audit.", + "open_questions": [ + { + "question": "Can a changed paid child operating on independently available input lanes avoid this source and returned basis obstruction?", + "why_it_matters": "More fixed monomial arms on the same two bases give no savings in the exact family.", + "first_step": "Specify two independently available inputs and its shared typed action, then price all eligible distinct old jobs before selecting a site.", + "blocked_by": "Exact phases, independent source availability, complete paid volume, routing, ownership and restoration, precision and tape all need a proof." + } + ] +} diff --git a/research/p104-finite-monomial-decoder-bound/TWO-ARM-AUDIT.json b/research/p104-finite-monomial-decoder-bound/TWO-ARM-AUDIT.json new file mode 100644 index 0000000000..aacedbff69 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/TWO-ARM-AUDIT.json @@ -0,0 +1,31 @@ +{ + "audited_tensor_raw_upper": "-350779588127118525082196069/2500000000000000000000000", + "groups": 898, + "identical_output_cosets": 0, + "moves": 6281, + "ordered_pairs": 2602, + "pins": { + "TWO-ARM.json": "92095d8281ee0c895aafee22092c21786d905948ace6fdf2902bc7f0642eb408", + "deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38", + "deps/round11/frontier/independent_adapter_price.py": "2a46157d156bdfc0e892289005fd3fb7c23708de48c9abd90c1914b0372bc726", + "inputs/native/RESULT.json": "75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49", + "inputs/native/WORD.json.gz": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f", + "prior/audit.py": "7270c06773d17a0d5ac80dd17e53eca076a5dfe92a87659ea345845fb594dc61" + }, + "source_bypasses_independent": 0, + "stats": { + "source_bypass_unavailable": 1086, + "source_monomial_bypass": 1086, + "three_distinct_tensor_rejected": 1516, + "width_one_direction_fail": 763, + "width_one_direction_pass": 1839, + "width_one_independent_pass": 685 + }, + "status": "PASS_INDEPENDENT_CLIFFORD_PROJECTIVE_AVAILABILITY_AND_PRICE", + "synthetic_control": { + "tensor_3_target_row_support": 64, + "tensor_3_two_returned_plus_source_support_upper": 17, + "width_one_signed_columns_equal": 4 + }, + "width_one_paid_savings_upper": 11645 +} diff --git a/research/p104-finite-monomial-decoder-bound/VERIFY.json b/research/p104-finite-monomial-decoder-bound/VERIFY.json new file mode 100644 index 0000000000..a619cb08eb --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/VERIFY.json @@ -0,0 +1,19 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/replay.py" + ], + "timeout_seconds": 360, + "checks": "Authenticate exact #7244/#7113 and all inherited inputs, regenerate the scoped stock and deadline receipts, and independently audit the finite-monomial tensor gate." + } + ] +} diff --git a/research/p104-finite-monomial-decoder-bound/audit.py b/research/p104-finite-monomial-decoder-bound/audit.py new file mode 100644 index 0000000000..307a42221f --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/audit.py @@ -0,0 +1,164 @@ +"""Independent primitive-row, signed-tableau and source-availability audit.""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +from functools import cache +from hashlib import sha256 +from importlib.util import module_from_spec, spec_from_file_location +from math import gcd, lcm +from pathlib import Path +import argparse +import gzip +import json + +PINS = { + 'inputs/native/WORD.json.gz': '75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f', + 'inputs/native/RESULT.json': '75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49', + 'deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py': '3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38', + 'deps/round11/frontier/independent_adapter_price.py': '2a46157d156bdfc0e892289005fd3fb7c23708de48c9abd90c1914b0372bc726', +} + + +def checked(root, key): + p = root / key + raw = p.read_bytes() + assert sha256(raw).hexdigest() == PINS[key] + return p, raw + + +def load(root, key): + path, _ = checked(root, key) + spec = spec_from_file_location(path.stem, path) + module = module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def span(vectors): + out = {0} + for x in vectors: + out.update(x ^ y for y in tuple(out)) + return frozenset(out) + + +def primitive(row): + den = lcm(*(x.denominator for x in row.values())) + z = [(i, x.numerator * (den // x.denominator)) for i, x in sorted(row.items())] + g = gcd(*(v for _, v in z)) * (1 if z[0][1] > 0 else -1) + return tuple((i, v // g) for i, v in z) + + +def run(root): + w = json.loads(gzip.decompress(checked(root, 'inputs/native/WORD.json.gz')[1])) + frozen = json.loads(checked(root, 'inputs/native/RESULT.json')[1]) + interp = load(root, 'deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py') + price = load(root, 'deps/round11/frontier/independent_adapter_price.py') + typed_raw = (root / 'TYPED.json').read_bytes() + gate_raw = (root / 'GATE.json').read_bytes() + typed, gate = json.loads(typed_raw), json.loads(gate_raw) + frames = [interp.frame(f, 9) for f in w['frames']] + inverses = [interp.adjoint(f) for f in frames] + cosets = [span(x | (z << 9) for x, z, _ in interp.tableau(f)[9:]) for f in inverses] + target_rows = defaultdict(set) + claimed = {} + for group in typed['eligible_group_details']: + row = primitive({j: Q(c) for j, c in group['projective_row']}) + claimed[row] = [e['event'] for e in group['members']] + for e in group['members']: + target_rows[cosets[e['source']], len(row)].add(row) + positions = [*w['initial'], *([None] * w['owned_fields'])] + rows = [{j: Q(1)} for j in range(w['public'])] + [{} for _ in range(w['owned_fields'])] + earliest = defaultdict(dict) + by_row = defaultdict(list) + by_event = {} + touches = defaultdict(list) + + def record(j, cut): + if not rows[j]: + return + f = cosets[positions[j]] + choices = target_rows.get((f, len(rows[j]))) + if choices: + k = primitive(rows[j]) + if k in choices: + earliest[f, k].setdefault(j, cut) + + for j in range(w['public']): + record(j, 0) + for t, (op, j, *a) in enumerate(w['program']): + touches[j].append(t) + if op == 'MOVE': + f, g, own = a + assert positions[j] == f and rows[j] and own == (j >= w['public']) + k = primitive(rows[j]) + by_row[k].append(t) + by_event[t] = (j, f, g, abs(len(w['frames'][g]) - len(w['frames'][f]))) + positions[j] = g + elif op == 'ADD': + source = a[0] + assert positions[j] == positions[source] == a[-1] + touches[source].append(t) + c = Q(a[1]); x, y = rows[j], rows[source] + rows[j] = {i: v for i in x.keys() | y.keys() if (v := x.get(i, 0) + c * y.get(i, 0))} + elif op == 'COPY': + source = a[0] + assert not rows[j] and positions[j] == positions[source] == a[-1] + touches[source].append(t) + rows[j] = {i: Q(a[1]) * x for i, x in rows[source].items()} + elif op == 'SCALE': + rows[j] = {i: Q(a[0]) * x for i, x in rows[j].items()} + else: + assert op in ('INIT', 'CLEAR') + rows[j] = {} + positions[j] = a[0] if op == 'INIT' else None + record(j, t + 1) + assert len(by_event) == 6281 + target = {k: v for k, v in by_row.items() if len({cosets[by_event[e][2]] for e in v}) > 1} + assert claimed == target and len(by_row) == typed['row_groups'] + deadline = {a: b for trace in touches.values() for a, b in zip(trace, trace[1:]) if a in by_event} + + @cache + def direction(f, g): + return span(x for x, _, _ in interp.tableau(inverses[g] + frames[f])[9:]) + + circular = 0 + total = 0 + credit = Counter() + for k, members in target.items(): + keep = min(members, key=lambda e: (by_event[e][3], e)) + credit.update(by_event[e][3] for e in members if e != keep) + for keep in members: + _, f, g, _ = by_event[keep] + for remove in members: + if keep == remove: + continue + total += 1 + j, _, h, _ = by_event[remove] + wanted = direction(f, h) + if wanted != {0} and wanted != direction(f, g): + continue + close = deadline.get(remove, len(w['program'])) + sources = earliest[cosets[f], k] + assert min(sources.values()) <= close and wanted == {0} + assert min(sources.items(), key=lambda z: (z[1], z[0])) == (j, remove + 1) + assert all(t > close or (role == j and t > remove) for role, t in sources.items()) + circular += 1 + assert total == gate['tested_pairs'] and circular == gate['passed_by_mode']['support_any_original_resident'] + assert not gate['survivors']['support_independent_original_resident'] + assert {str(k): n for k, n in credit.items()} == typed['skipped_child_hist'] + p = Counter({int(k): n for k, n in frozen['price']['after']['P'].items()}) + t = Counter({int(k): n for k, n in frozen['price']['after']['T'].items()}) + t.subtract(p) + upper = sum(n * price.price(r)[n > 0] for r, n in t.items() if n) + assert upper <= Q(typed['baseline'][1]) < 0 + return dict(status='PASS_INDEPENDENT_PROJECTIVE_AND_TYPED_AVAILABILITY', moves=len(by_event), + row_classes=len(by_row), eligible_groups=len(target), tested_pairs=total, + circular_rank_zero_pairs=circular, independent_pairs=0, source_pins=PINS, + audited_baseline_upper=price.encode((upper, upper))[1], + receipts={'TYPED.json': sha256(typed_raw).hexdigest(), 'GATE.json': sha256(gate_raw).hexdigest()}) + + +if __name__ == '__main__': + assert __debug__ + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('root', type=Path) + print(json.dumps(run(**vars(p.parse_args())), indent=2, sort_keys=True)) diff --git a/research/p104-finite-monomial-decoder-bound/audit_two_arm.py b/research/p104-finite-monomial-decoder-bound/audit_two_arm.py new file mode 100644 index 0000000000..901d85af37 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/audit_two_arm.py @@ -0,0 +1,186 @@ +"""Independent primitive-row, Clifford support and price recount.""" +from bisect import bisect_right +from collections import Counter, defaultdict +from fractions import Fraction as Q +from functools import cache +from hashlib import sha256 +from importlib.util import module_from_spec, spec_from_file_location +from pathlib import Path +import argparse +import gzip +import json + + +PRIOR_AUDIT = '7270c06773d17a0d5ac80dd17e53eca076a5dfe92a87659ea345845fb594dc61' + + +def synthetic_control(interp): + returned = (('C', 1, 1),) + target = returned + (('C', 2, 1),) + # C_2 = ((1+i) I + (1-i) X_2)/2 on the second bit. + for j in range(4): + src, den = interp.state(returned, j) + want, power = interp.state(target, j) + got = defaultdict(lambda: (0, 0)) + for k, (a, b) in src.items(): + for address, pair in ((k, (a - b, a + b)), (k ^ 2, (a + b, b - a))): + old = got[address] + got[address] = (old[0] + pair[0], old[1] + pair[1]) + assert {k: (Q(a, 2 ** (den + 1)), Q(b, 2 ** (den + 1))) for k, (a, b) in got.items()} == { + k: (Q(a, 2 ** power), Q(b, 2 ** power)) for k, (a, b) in want.items()} + returned3 = tuple(('C', 1 << (2 * j), 1) for j in range(3)) + target3 = returned3 + tuple(('C', 2 << (2 * j), 1) for j in range(3)) + r = len(interp.state(interp.adjoint(returned3))[0]) + s = len(interp.state(interp.adjoint(target3))[0]) + assert (r, s) == (8, 64) and 2 * r + 1 < s + return {'width_one_signed_columns_equal': 4, 'tensor_3_target_row_support': s, + 'tensor_3_two_returned_plus_source_support_upper': 2 * r + 1} + + +def run(root): + path = root / 'prior/audit.py' + assert sha256(path.read_bytes()).hexdigest() == PRIOR_AUDIT + spec = spec_from_file_location('prior_audit', path) + a = module_from_spec(spec) + spec.loader.exec_module(a) + word = json.loads(gzip.decompress(a.checked(root, 'inputs/native/WORD.json.gz')[1])) + frozen = json.loads(a.checked(root, 'inputs/native/RESULT.json')[1]) + independent = a.load(root, 'deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py') + price = a.load(root, 'deps/round11/frontier/independent_adapter_price.py') + typed = json.loads((root / 'prior/TYPED.json').read_bytes()) + raw = (root / 'TWO-ARM.json').read_bytes() + report = json.loads(raw) + frames = [independent.frame(x, 9) for x in word['frames']] + inverse = [independent.adjoint(f) for f in frames] + cosets = [a.span(x | (z << 9) for x, z, _ in independent.tableau(u)[9:]) for u in inverse] + wanted = defaultdict(set) + claimed = {} + for group in typed['eligible_group_details']: + line = a.primitive({j: Q(q) for j, q in group['projective_row']}) + claimed[line] = [e['event'] for e in group['members']] + for e in group['members']: + wanted[cosets[e['source']], len(line)].add(line) + + public = word['public'] + resident = [{i: Q(1)} for i in range(public)] + [{} for _ in range(word['owned_fields'])] + chart = [*word['initial'], *([None] * word['owned_fields'])] + first = defaultdict(dict) + touches = defaultdict(list) + moves = {} + by_line = defaultdict(list) + + def observe(j, cut): + row = resident[j] + if row: + coset = cosets[chart[j]] + match = wanted.get((coset, len(row))) + if match: + line = a.primitive(row) + if line in match: + first[coset, line].setdefault(j, cut) + + for j in range(public): + observe(j, 0) + for cut, (op, j, *args) in enumerate(word['program']): + touches[j].append(cut) + if op == 'MOVE': + f, g, owned = args + assert chart[j] == f and owned == (j >= public) and resident[j] + r = abs(len(word['frames'][g]) - len(word['frames'][f])) + by_line[a.primitive(resident[j])].append(cut) + moves[cut] = (j, f, g, r) + chart[j] = g + elif op == 'ADD': + k, c, f = args + assert chart[k] == chart[j] == f + touches[k].append(cut) + p, q = resident[j], resident[k] + factor = Q(c) + resident[j] = {i: v for i in p.keys() | q.keys() if (v := p.get(i, 0) + factor * q.get(i, 0))} + elif op == 'COPY': + k, c, f = args + assert chart[k] == chart[j] == f and not resident[j] + touches[k].append(cut) + resident[j] = {i: Q(c) * v for i, v in resident[k].items()} + elif op == 'SCALE': + c, f = args + assert chart[j] == f + resident[j] = {i: Q(c) * v for i, v in resident[j].items()} + else: + assert op in ('INIT', 'CLEAR') and j >= public + chart[j] = args[0] if op == 'INIT' else None + resident[j] = {} + observe(j, cut + 1) + assert chart == [*word['final'], *([None] * word['owned_fields'])] + groups = {k: v for k, v in by_line.items() if len({cosets[moves[e][2]] for e in v}) > 1} + assert claimed == groups and len(moves) == 6281 + + @cache + def direction(f, g): + return a.span(x for x, _, _ in independent.tableau(inverse[g] + frames[f])[9:]) + + stats = Counter() + width_positive = set() + width_hist = Counter() + for line, group in groups.items(): + candidates = set() + assert len({cosets[moves[e][2]] for e in group}) == len(group) + for e in group: + _, f, g, r = moves[e] + d = direction(f, g) + assert len(d) == 2 ** r > 1 + for omitted in group: + if e == omitted: + continue + stats['ordered_pairs'] += 1 + role, _, h, _ = moves[omitted] + want = direction(f, h) + between = direction(g, h) + assert len(between) > 1 + stats['three_distinct_tensor_rejected' if len(want) > 1 else 'source_monomial_bypass'] += 1 + if len(want) > 2 * len(d & want): + stats['width_one_direction_fail'] += 1 + continue + stats['width_one_direction_pass'] += 1 + clock = touches[role] + i = bisect_right(clock, omitted) + deadline = clock[i] if i < len(clock) else len(word['program']) + possible = first[cosets[f], line] + independent_source = any(cut <= deadline and (j != role or cut <= omitted) for j, cut in possible.items()) + if len(want) == 1: + assert not independent_source + stats['source_bypass_unavailable'] += 1 + if independent_source: + assert len(want) > 1 + stats['width_one_independent_pass'] += 1 + candidates.add(omitted) + width_positive.add((e, omitted)) + if len(candidates) == len(group): + candidates.remove(min(candidates, key=lambda e: (moves[e][3], e))) + width_hist.update(moves[e][3] for e in candidates) + assert report['tested_pairs'] == stats.pop('ordered_pairs') == 2602 + assert report['stats'] == dict(stats) + assert {(e['kept'], e['omitted']) for e in report['survivors']['width_one_independent']} == width_positive + assert not report['survivors']['tensor_finite_arms_independent'] + assert {str(k): v for k, v in width_hist.items()} == report['width_one_independent']['savings_hist'] + assert width_hist == {1: 685} + paid = Counter({int(k): v for k, v in frozen['price']['after']['P'].items()}) + productive = Counter({int(k): v for k, v in frozen['price']['after']['T'].items()}) + productive.subtract(paid) + upper = sum(n * price.price(r)[n > 0] for r, n in productive.items() if n) + assert upper <= Q(report['tensor_independent']['raw_margin_upper']) < 0 + assert upper + 17 * width_hist[1] > 0 + return dict(status='PASS_INDEPENDENT_CLIFFORD_PROJECTIVE_AVAILABILITY_AND_PRICE', + moves=len(moves), groups=len(groups), ordered_pairs=report['tested_pairs'], + source_bypasses_independent=0, identical_output_cosets=0, + width_one_paid_savings_upper=17 * width_hist[1], stats=dict(stats), + audited_tensor_raw_upper=price.encode((upper, upper))[1], + synthetic_control=synthetic_control(independent), + pins={'prior/audit.py': PRIOR_AUDIT, 'TWO-ARM.json': sha256(raw).hexdigest(), **a.PINS}) + + +if __name__ == '__main__': + assert __debug__ + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('root', type=Path) + print(json.dumps(run(**vars(p.parse_args())), indent=2, sort_keys=True)) diff --git a/research/p104-finite-monomial-decoder-bound/contracts/PROOF.md b/research/p104-finite-monomial-decoder-bound/contracts/PROOF.md new file mode 100644 index 0000000000..fcda156f89 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/contracts/PROOF.md @@ -0,0 +1,64 @@ +# Two paid exits and two causal splits + +The source is exact [#7161](https://github.com/CrocSwap/integer-mult-bounds/pull/7161) at +`e3f8d39c43b07063dfc5b800f71c5d21015259e6`. Roles 988 and 991 +both enter at chart 3 and return at rank-eight chart 245. Extend both +returns by a paid rank-one MOVE from 245 to 127. The enlarged group has +618 arbitrary helper coordinates on the common `(3,127)` boundary. +The signed caller is exact [#7113](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +at `07a76c5e2738882c0cb322278e56f6cae3c9885d`. + +## Guarded directions + +The literal cuts are 45,614 at chart 1091 with pivot 998, and 58,854 +at chart 245 with pivot 988. A cut is the position before the event with +that zero-based index. The witness preserves the complete order of the +original events. The first prefix and guarded suffix use eight gathers +and seven injections. The second prefix is the difference of roles 988 +and 991, and the second suffix is half their difference. +[WITNESS.json](WITNESS.json) gives every role, cut and coefficient. + +In normalized coordinates let $C$ have the two prefix rows and let $D$ +have the two suffix columns. The replay computes every coordinate, +including outside the group, all final owned roles and the actual +pre-COPY destination guard. It checks $CD=I_2$. The first injection +changes the values of 988 and 991 by the same coefficient 8 at the +second cut. The second gather therefore has zero response to the first +injection, for every value of the first new input. The second injection +occurs after all first gathers. + +## Arbitrary-input construction + +The literal scalar basis $B$ has pivot rows $C$ and maps the columns of +$D$ to the corresponding pivot units. The first set of row operations +reduces the first column and sets the first pivot row. Orthogonality +puts the transformed second row and column in the complement of that +pivot, where the remaining operations reduce them. Apply $B^{-1}$ at +chart 3 and $B$ after both charged exits reach chart 127. + +At each cut, a live pivot value $v_i$ is transferred to the continuation +and its retiring field receives $x_i$, the gathered original pivot +input. A separate owned buffer holds $z_i-x_i$, where $z_i$ is the +arbitrary new continuation input. The guarded suffix adds +$d_i(z_i-x_i)$. The emitted program preserves the live value $v_i$ even +when it differs from $x_i$. The equality of the two late donor responses +ensures the second gathered value is still $x_2$. Applying the final +basis gives $x+e_{998}(z_1-x_1)+e_{988}(z_2-x_2)$ on the continuing +group. The retiring fields return $x_1,x_2$ at charts 1091 and 245. +All four added owned lifetimes clear explicitly. + +## Complete invoice + +The two exit extensions change two targets from rank eight to rank nine. +The first retirement replaces one rank-nine target by ranks four and +five. The second replaces one by ranks eight and one. Thus the literal +per-native change is `T1 +1, T4 +1, T5 +1, T8 −1, P1 +2`. The signed +caller charges the change in all 17 native occurrences. Rank surplus +stays 1,424. For $p=1-C$ in $(0,1)$, the change in the signed moment per +occurrence is $4^p+5^p-8^p-1>0$ by strict concavity. The exact compiler +and outer receipt separately bounds the realized conditional price. + +The same five framework assumptions govern the conditional bound. +These cover all-column native maps, owned erasure, the compiler, +precision and tape bounds, and analytic recovery. The source and +finite application checks give a candidate for maintainer review. diff --git a/research/p104-finite-monomial-decoder-bound/contracts/SOURCES.json b/research/p104-finite-monomial-decoder-bound/contracts/SOURCES.json new file mode 100644 index 0000000000..6b97e903a6 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/contracts/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md", + "usage": "provenance", + "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695", + "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055" + }, + { + "path": "research/final4610-independent-admission/checks/outer.py", + "usage": "input", + "git_blob": "39e62cac780b662903582cb5f8684990fa779bb3", + "sha256": "196be1bc2329500f2c7c995deaf5a82aecc5e27f0fef7805470cb65d187bb1c0" + }, + { + "path": "certificates/frontier7000/CLAIM.json", + "usage": "input", + "git_blob": "c9b816f8445be9dc19b2259e03e9d8709d18c87a", + "sha256": "3f8add8252adb223b60418ec69351a69b6b5edfe601ec1c6b4b65cd9e2afd9b2" + } + ] +} diff --git a/research/p104-finite-monomial-decoder-bound/contracts/canonical-PROOF-REVIEW.md b/research/p104-finite-monomial-decoder-bound/contracts/canonical-PROOF-REVIEW.md new file mode 100644 index 0000000000..3dd1af2285 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/contracts/canonical-PROOF-REVIEW.md @@ -0,0 +1,420 @@ +# Current-source conditional application of #7000 and #7001 + +This continuation applies the five assumptions of selected #6030 to Jerry +Chen / CubeJerry's #7000 (`93effe2a135bf57b9e484cb630d8dd057159aec9`) and +#7001 (`d777f3a0aa2878bea0478918923dabcf86b9878b`). It supplies the owner, +geometry, exact-scalar, root-boundary and finite-cost substitutions left open +by [the preceding review](../pr7000-admission/PROOF-REVIEW.md). +The claimed complex saving is **κ=.00363005817**. + +**Decision: admit κ=.00363005817 under the same five retained assumptions.** +All 18 required executions have completed: eleven source-bound receipts from +the preceding review and seven new executions. The complete native catalogue +parts pass in 222.34, 249.59 and 338.04 seconds; their peak sampled descendant +memory is below 60,000 KiB. Normal and optimized application/scalar checks pass. +The 600-second monolithic timeout is separately retained and contributes no +completed coverage. The source manifest, claim and replay driver bind this +decision to the exact construction and the 134-axis BIT repair. + +This is a conditional application theorem. The native/owned-storage, +compiler, fixed-tape movement and analytic/recovery assumptions are retained, +not proved here. No complete uniform word, literal multiplier execution, +independent human proof or formal-kernel proof is asserted. Execution status +and the admission decision are recorded in VALIDATION.json; prose does not +turn an unfinished check into a pass. + +## 1. Exact coverage and the admission standard + +The previous five registered replays, two supporting local checks and four +normal/optimized review checks are reused only at their recorded scientific +input hashes. They cover cold construction, scalar endpoints, current frame +and owned chronology, COPY into ideal zero, the complete formal caller, +paid/target invoices, independent rational interval inequalities and finite +512-component corroboration. Their original limits remain explicit. + +New `check_application.py` imports no contributor scientific code. It checks +the actual mixed caller's port/owner allocation and all 14,400 native boundary +contacts through degree-two phase polynomials modulo four; it also checks +636 rational BIT frames and 111 main charts. Its ordered job digests bind +117,612 complex and 107,352 BIT paid positions to their actual owners. +Aliased mains, wrong stages, singular spectator bases and omitted contact +translations are rejected. Normal and optimized runs agree. + +The candidate's chart-delta check covered 73 new maps; archive status did +not establish the remaining maps. `check_native_catalogue.py` therefore +checks the complete current union of paid and helper maps, including the +inherited ones, plus every main boundary pair. It uses the pinned Clifford +compiler and the distinct signed-Pauli/Gaussian-phase interpreter. Equal +signed Pauli action fixes a Clifford up to scalar; an exact Gaussian state +fixes that scalar, so this determines the full matrix, not a random sample. +The generic nested-frame factorization and its product lift then apply. +The 3,057-map catalogue is partitioned into the disjoint index intervals +[0,1000), [1000,2000), [2000,3057) of one authenticated sorted catalogue; +the final part also checks all 104 main-boundary pairs. An earlier monolithic +run reached its 600-second limit and is retained as a failed execution, not +reused as completed coverage. Each part repeats the global-phase fault control. + +The exact fixed-rational scalar reference is separate from those engines. +It exercises all 4,469 source/conversion coefficients on 100,148 signed +bit-state cases and rejects 4,149 nonexact division controls. The all-width +argument below follows from the finite carry/remainder invariants, not from +extrapolation of those finite tests. + +## 2. Complex local words and complete physical caller + +For a live field with frame U, write its physical value as +`T_U^(tensor f) z`, on all nine native slots and complete spectators. +Every MOVE applies the exact quotient of its two frames; every scalar +contact is between equal current frames. Consequently the source's exact +scalar endpoint is an identity on arbitrary full arrays at every f, with +the exterior rational coefficients unchanged. A nested quotient factors +as `L C_r R`; tensor the product to obtain one positive rank-rf child with +its two monomial adapters. Absolute phase `i^a` becomes `i^(af)`. +No tensor power is distributed over an ADD or a matrix sum. + +Every autonomous helper is normalized only around the whole completed +native invocation. Its two-sided factors need not be inverses. The new +splits retain their independently checked arbitrary-input cut identities. +There are 400 mains, 1,080 independent helpers and 51 owned native labels. +The 23 owned rises have the exact recipes checked in the preceding review; +the current word's peak is 43 and its 54 lifetimes are checked chronologically. +The retained completed-child rule permits correlated current owned contents; +it does not permit aliasing fields or resuming before complete return. + +For the caller use nine central axes and eighteen disjoint eight-axis stage +blocks, ambient **153**. For each actual odd central direction q, the source +provides an orthonormal basis `[q,b1,...,b8]`. At stage s the map R exchanges +the b directions with that stage's eight standard axes, fixes q and fixes +every other coordinate. The checker verifies its full inverse and spectators. + +Here is the absolute-phase test. Write `Γ(t)=product_v C_v^(t_v)`. +Its character phase is `sum_v t_v parity(v·x) mod4`. Expanding parity gives +linear coefficients and quadratic coefficients modulo four; there are no +higher terms. A residual is an ordinary translation exactly when all +quadratic coefficients vanish and all linear coefficients are even. The +checker computes these coefficients, installs the translation and verifies +both directions of each contact. These Γ frames are auxiliary expressions +for proving the intertwining identities; they are not extra uncharged +Fourier operations executed at the caller entrance. + +After the retained main-boundary monomials, the native endpoint is exactly + +``` +type A, first plane: D_s (x, y + Q^-1 x) +type A, second plane: D_s (u - Q v, v) +type B: D_s (x - Q y, (Q^-1 x + y)/2). +``` + +The second-plane native boundary frames equal the first-plane frames; the +four physical fields are nevertheless distinct. The checker binds all +18 invocations, 96 type-A ports and eight type-B ports. For every invocation, +400 main slots map injectively to the named current caller owners; all 1,080 +helpers have fresh `(invocation, native slot)` tags. No equality of frames +or values merges two owners. The complete raw unit has **23,392** productive +fields: 3,952 root fields and 19,440 helpers. + +Each native MOVE retains its actual position and owner. QUERY uses a separate +full scratch, copies by ADD, executes the signed positive rank-one child and +its adapters, adds the result and clears before proceeding. Its 416 uses +are paid. The 3,616 whole idles act on the union of their distinct selected +stage blocks and are paid once on that owner. The 14,480 global LAMBDA uses +have the ordinary translation-and-scalar lowering established previously; +they create no child or target. A single full query/normalizer bank can be +reused serially; conservatively reserve all 18·51 native banks separately. + +The checked caller identity is in `Q(i)[q,D1,...,D18]/(q^4-1)`, retaining +free body powers. The actual Q has order four, and the stage factors commute +on disjoint complete axes, so substitution is valid at every f. Each output +is a product of distinct stage factors and Q or Q^-1. The latter has the +exact ordinary correction Q². Thus every target is a positive whole job +with charged boundaries and complete spectators. The resulting complete +invoice agrees with the independently replayed P,T and has surplus 1,520. + +## 3. BIT frame, paired-call and delayed-cover application + +A BIT frame supplies rational row bases B for its selected space and A for +its annihilating complement. The new check verifies their dimensions, +annihilation and invertibility of `G=[B^T A^T]` for **all 636 frames**. +It therefore defines the rational projector +`P=G diag(I_dim,0) G^-1`. On the two complete address chunks, the partial +interchange has block matrix `[[I-P,P],[P,I-P]]`. For nested frames, +the projectors commute and their product is the smaller projector; their +interchange quotient is the interchange on the positive-rank difference. +Changing to a basis of that difference and back is precisely the retained +rational whole-job interface. Source XOR contacts commute with a common +current address permutation. The already replayed binary endpoint therefore +lifts to complete chunks and arbitrary payloads, with owned erasures retained. + +For each of the 111 main ports, `[u,B_body]` is an invertible rational basis +with one head and seven complementary body directions. At a stage, exchange +those seven basis directions with seven fresh stage coordinates, fixing u +and all external spectators. In this basis that map is a coordinate +involution; conjugating it gives the explicit rational map on actual fields. +It conjugates the body projector to the stage projector and fixes the head +projector. These equations prove the simultaneous main/body interface; +orthonormality of the seven rational body vectors is not needed. + +The paired caller executes two real native invocations at each stage on +disjoint main pairs. Each invocation receives its own 437 helpers and 237 +owned labels. The full allocation gives **19,950** distinct productive +fields, 107,352 paid positions, 8,532 conservatively reserved native banks +and one serial query bank, before compiler/primitive workspace. The four +queries and every whole idle are charged. Integral transfer occurs before +reduction modulo two; no fraction 1/2 is reduced in characteristic two. +The finite caller equality in `F2[q,D1,...,D18]/(q²-1)` consequently supplies +the stated completed positive outputs without empty-root credit. + +The complete working cap is **134**, as repaired previously. Rational native +maps and subsequent finite compiler matchers form a finite catalogue before +the cover prime is chosen. Choose q larger than the retained cover bound and +avoiding all denominators, nonzero determinants and fixed rank witnesses of +that entire catalogue. The checker's finite witness list concerns the raw +source only; it is not claimed to contain the later compiler's exclusions. +The delayed whole-cover theorem handles right routes `g -> gS` with fixed +rational S. It does not exclude q-dependent cover entries, discard nonunit +pivots without charging the bad classes, or permit weights depending on a +child's fresh cover/roles. External weights may depend on exposed ancestors. + +Use the repaired power 768, cutoff 15, floor 16, logarithm power 617, +`H_B=296630000000000`, and the two separate 10^-10 losses. The covered +saving is .0038525298. Freeze two ordinary backends in order: + +``` +.0034 -> .0038507 -> .00385248. +``` + +The first backend is the selected completed .0034 interface, including its +spectators, restored stock and radix boundary. Each subsequent algorithm +uses only its completed predecessor for ordinary maps/high-part exchanges, +with atom exponent ρ=1/250. Its source-bound cost is +`O(C V [e^(1-ρ) + e^((1-ρ)(1-covered)+ρ(1-previous)) + e^ρ log e])`. +The exact positive bootstrap gaps were checked previously. C is the new +finite constant, not one. Freeze each backend's threshold before using it +in the next step; smaller widths use the predecessor. This dependency is +acyclic and supplies the weaker .00376669 used by the complex outer ledger. + +Reserve the full input-dependent row stock with +`D_stock(e)=2+ceil(log_(N_B)(max(1,ceil(e/ceil(e^ρ)))))` and +`W(w)^D_stock(e) S_old`, as in the pinned delayed-cover proof. The high-digit +reserve is `O_fixed(w log e)`. Internal BIT recursion preserves the entire +external complex factor and restores its own borrowed stock. The fixed two +backend levels are not substituted for the input-dependent recursion depth. + +## 4. Exact fixed-rational scalar service + +Choose the per-native-call scale-1125 route, not the independently rounded +ADD implementation. Multiply each actual public entrance by S=1125, execute +the literal word, and divide each completed output by S. All 53,280 boundary +conversions are counted. The previously checked row and pre-product invariant +proves odd divisibility on the common grid described below. + +For a fixed reduced scalar a/b, multiply an unsigned magnitude bit stream +least-significant-bit first. Its state is carry c, and the transition on bit +u emits `(c+|a|u) mod2` and retains `floor((c+|a|u)/2)`. The carry remains +between 0 and |a|; append `bitlength(|a|)+1` zero bits. Reverse direction +for division by fixed positive b. From remainder r and bit u, form `2r+u`, +emit its comparison with b, and keep the remainder after subtracting b when +necessary. Here `0<=r=1, +integer logarithmic degree d0 and positive rational slack δ in the retained +outer bounds, choose an integer j beyond `4d0/δ` with +`C(j+1)^d0 <= 2^(δj)` and freeze the input threshold at least 2^j. Subsequent +ratios decrease, so the inequality holds thereafter. Choose j on a multiple +of δ's denominator to make this an integer comparison. Likewise the retained +record fiber `2^(Omega(p^(1-epsilon)))` eventually exceeds every new fixed +descriptor polynomial; choose the cutoff after its constants/degrees. +Take the maximum of these finitely many cutoffs, the scalar-fit boundary, +stock conditions and the primitive-family cutoffs. No input-dependent +algorithm or growing tape alphabet is introduced by this choice. + +## 7. Compiler funding and outer conclusion + +The independently checked complex invoice has tested price +`C=.00363005817007=κ+7g`, `g=10^-14`. Use product power 1920, cutoff 11, +completion floor 12, offset 1/7 and actual ambient `153^1920`. +The certified bounds give `alpha<1-10^-27`, `gamma,delta<31/32` and +`1/(1+1920·10^-27)+4(31/32)^1920<1`. The separated paid ceiling is below +the target floor. Whole-job completion and integer splitting retain all +their arrays, paid positions and fresh adapters. + +The ambient-cap proof supplies the source band `(N/A,N]` with A=153^1920; +no target of rank A is needed. Logarithm power 2228 and +`H_C=14174600000000000000` give the checked uniform saving `κ+6g`. +All 54 strict and four functional outer predicates pass; their minimum +positive margin is 10^-15. The completed BIT saving .00385248 supplies the +weaker .00376669 premise with ample positive margin. Section 6 changes finite +constants and eventual thresholds, leaving these rank and exponent inequalities +unchanged. The resulting conclusion is the conditional bound + +`T(n)=O(n (log n)^(1-.00363005817))`. + +The five assumptions are still native_all_columns, owned_erasure, compiler, +precision_tape and analytic_recovery. Local owned ascent, global LAMBDA, +mixed/shared native calls and exact odd division have explicit applications +within those assumptions above. The conclusion does not admit arbitrary +rounded providers, the old numerical tape-cost cap, or newer words with the +same headline/interface names. Any changed source needs its affected checks. + +## Attribution and open next questions + +CubeJerry supplied #7000/#7001 and the precision, owned-ascent, global-LAMBDA +and compiler-application work. DreamingOfClouds supplied the shared native, +two-chain and helper constructions; Ali Romman supplied the helper-basis +lineage. Retain zxv's rational BIT/native/compiler work, Jacob Alan Sussman's +mixed integer compiler, icekylinx/Dugongue's frame theory, Cinna Davis, +Matarener, Chris R/Clear1nsight and all unchanged NOTICE attributions. +The phase-polynomial route method and common-grid induction are credited +reuses; the current occurrence map, complete catalogue closure, exact-scalar +application and finite-cost/root-boundary substitutions are this review's work. +Prepared for Douglas Colkitt with substantial OpenAI Codex assistance, +Apache-2.0; no separate human or formal-kernel verification. + +Open next questions: implement the complete fixed-tape dispatcher rather than +its conditional grammar; tighten the deliberately loose scalar/route constants; +and transfer this application to later changed words using exact-source deltas. +Those questions do not turn an archived successor into an admitted result. diff --git a/research/p104-finite-monomial-decoder-bound/contracts/pr7161-PROOF.md b/research/p104-finite-monomial-decoder-bound/contracts/pr7161-PROOF.md new file mode 100644 index 0000000000..0e20dca0d4 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/contracts/pr7161-PROOF.md @@ -0,0 +1,91 @@ +# One paid exit funds the chart-1031 split + +The source is [#7156 at b44944c3058d522cbff17836e16240d40d77a927](https://github.com/CrocSwap/integer-mult-bounds/tree/b44944c3058d522cbff17836e16240d40d77a927/research/p104-temporal-chart306-continuation). +Its normalized native word returns every helper coordinate and leaves all +other outputs independent of those helper inputs. The candidate retains +the signed 17-stage [#7113 caller](https://github.com/CrocSwap/integer-mult-bounds/pull/7113) +at `07a76c5e2738882c0cb322278e56f6cae3c9885d`. + +## Literal exit extension and temporal access + +Role 133 starts at frame 3 and returns at frame 591 of rank eight. Append one +public MOVE from frame 591 to frame 127, whose span strictly contains it. +The unchanged scalar endpoint for role 133 now belongs to the arbitrary +helper group with boundary frames 3 and 127. The new MOVE has rank one and +is charged. Both the prefix and suffix vectors use role 133, so omitting +the extension makes the unchanged-boundary constructor reject the witness. + +At chart 1031 of rank five and original cut 42,379, pivot 1,336 is resident. +[WITNESS.json](WITNESS.json) binds twelve gathers and five injections to +the exact original cuts. Roles 1,362 and 1,386 are literal stationary +gathers at cut zero, with windows `[0,35561]` and `[0,35607]`. The other +fifteen observations use the contact-free retimings in +[PATHS.json](PATHS.json). The retiming preserves all original paid MOVE +ranks. Every read and write stays in one literal frame. + +Let P(t,r) be the complete normalized scalar prefix row at cut t, and let +S(t,r) be the suffix perturbation response in all final public and owned +coordinates and all COPY destination-zero guards. A guard for an injection +at cut t includes a COPY performed at event t. The two weighted sums give +the vectors c and d in the witness, with zero in every outside coordinate. +Their support intersection is roles 133, 445, 1,242 and 1,336. Its dot +product is `6 - 2 - 5 + 2 = 1`. The retained exact certificate recomputes +both vectors. Separate controls reject an omitted exit, a wrong exit +frame, a false stationary frame, a MOVE inside the claimed stationary +interval and an observation after CLEAR. + +## Arbitrary-input split + +The retained causal construction builds a scalar basis G with pivot row +c and `G d = e_pivot`. It applies G inverse at the input frame and G at +the final frame, where the paid extension has already arrived. Both +directions are emitted with the literal scalar coefficients. On original +group input u, the internal input is `G^-1 u` and the gathers put the +original pivot input x in an owned buffer A. + +At retirement let v be the current pivot continuation and z the independent +new public input at chart 1031. The literal middle operation leaves x in +the retiring pivot, v in its new continuation and z−x in a second owned +buffer B. The scheduled suffix injections add `d(z−x)` without changing +any other output or COPY guard. After the exit basis the continuing pivot +returns z, since `G(G^-1 u+d(z−x)) = u+e_pivot(z−x)`. The two owned +lifetimes retire explicitly. This is an arbitrary-input identity, +including when v differs from x. + +The common-frame scalar operators act on the normalized complete arrays +at every positive column multiplicity. A MOVE is the exact nested-frame +quotient with its absolute phase, and its tensor lift is one charged child +with two whole-job adapters. The separate native and complete caller +replays check the affected maps, phase, ownership, and exact grids. +The signed caller's 17 stages use the same distinct physical owner and +central-phase bindings as the selected application framework. + +## Complete price change + +The extended helper changes one rank-eight target to rank nine and adds +one paid rank-one child. The causal split then replaces one rank-nine +target with ranks five and four. Thus the net per-native change is +`T4 +1, T5 +1, T8 -1, P1 +1`. All seventeen occurrences are charged. +Rank surplus stays 1,424. For `p=1-C` in `(0,1)`, strict concavity gives +`4^p + 5^p - 8^p - 1 > 0`. The complete directed engines certify the +funded price `C=0.00364489006794007` and conditional +`κ=0.003644890067940`, an exact gain of `482172401/10^15` over #7156. +The original complete invoice has a strictly negative moment at the new +claim. The fixed BIT premise is 0.00376669. + +For a fixed-profile ceiling, hold this exact target invoice and the +seventeen native profiles fixed. The remaining paid rank mass is 109,088. +The most favorable fractional remainder under the ambient cap 145 puts +all that mass at rank 145, because `r^(-C)` decreases in r for positive C. +The early receipt certifies a decreasing relaxed crossing on `[0,1/32]` +and records the rational ceiling bracket and fraction realized. This +relaxation has different hypotheses from the nine-stage equal-target cap. +It bounds the fixed profiles and rank mass stated here. + +The common exact-grid, finite stock, movement, compiler and outer +application follows the [selected #7000/#7001 review](../../docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md) +and the [exact #7156 application review in #7158](https://github.com/CrocSwap/integer-mult-bounds/pull/7158). +Use the regenerated full ordinary and physical bills, common-grid bounds, +precision context and complete outer receipt for this candidate. The +five inherited assumptions remain native_all_columns, owned_erasure, +compiler, precision_tape and analytic_recovery. diff --git a/research/p104-finite-monomial-decoder-bound/decode_gate.py b/research/p104-finite-monomial-decoder-bound/decode_gate.py new file mode 100644 index 0000000000..8b028bd264 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/decode_gate.py @@ -0,0 +1,220 @@ +"""Necessary support and earliest-resident gate for a one-child/two-arm decoder.""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +from functools import cache +from hashlib import sha256 +from importlib.util import module_from_spec, spec_from_file_location +from pathlib import Path +from time import monotonic +import argparse +import json + + +STOCK_SHA = '68202ba9326938cb0bf5abbabb893c3db01090a22acb6ba55afaef1dbae2bf9c' + + +class TimeCap(Exception): + pass + + +def module(path): + spec = spec_from_file_location(path.stem, path) + m = module_from_spec(spec) + spec.loader.exec_module(m) + return m + + +def first_observation(word, eligible, frame_cosets, stock, time): + """Every literal input or changed state; free holding and source coset adapters.""" + wanted = defaultdict(set) + for group in eligible: + row = tuple(map(tuple, group['projective_row'])) + for e in group['members']: + wanted[frame_cosets[e['source']], len(row), row[0][0]].add(row) + first = defaultdict(dict) + public = word['public'] + states = [{i: Q(1)} for i in range(public)] + [{} for _ in range(word['owned_fields'])] + frames = [*word['initial'], *([None] * word['owned_fields'])] + + def observe(j, cut): + row = states[j] + if not row: + return + f = frame_cosets[frames[j]] + allowed = wanted.get((f, len(row), min(row))) + if allowed: + candidate = stock.proportional(row) + if candidate in allowed: + first[f, candidate].setdefault(j, (cut, j, frames[j])) + + for j in range(public): + observe(j, 0) + for t, (op, j, *a) in enumerate(word['program']): + if t % 256 == 0: + time() + if op == 'MOVE': + assert frames[j] == a[0] + frames[j] = a[1] + elif op == 'ADD': + assert frames[j] == frames[a[0]] == a[-1] + states[j] = stock.add(states[j], states[a[0]], Q(a[1])) + elif op == 'COPY': + assert not states[j] and frames[j] == frames[a[0]] == a[-1] + states[j] = stock.scale(states[a[0]], Q(a[1])) + elif op == 'SCALE': + assert frames[j] == a[-1] + states[j] = stock.scale(states[j], Q(a[0])) + # A nonzero SCALE leaves a projective row unchanged. + assert Q(a[0]) + continue + else: + assert op in ('INIT', 'CLEAR') + states[j] = {} + frames[j] = a[0] if op == 'INIT' else None + continue + observe(j, t + 1) + return first + + +def hist(rows): + return Counter(e['rank'] for e in rows) + + +def controls(): + def possible(r, s, same): + return s == 0 or (s == r and same) + assert not possible(1, 2, False) + assert not possible(3, 2, True) + assert not possible(3, 3, False) + assert possible(1, 1, True) and possible(3, 0, False) + return dict(larger_support_rejected=True, one_point_cannot_halve_rank_three=True, + different_equal_size_direction_rejected=True, zero_rank_source_bypass_allowed=True) + + +def run(root, seconds): + started = monotonic() + + def time(): + if monotonic() - started >= seconds: + raise TimeCap + + raw = (root / 'TYPED.json').read_bytes() + if sha256(raw).hexdigest() != STOCK_SHA: + raise ValueError('SHA-256 mismatch: TYPED.json') + old = json.loads(raw) + assert old['moves_pending'] == 0 + typed = module(root / 'typed_stock.py') + stock = typed.load_stock(root) + price = stock.load(root / 'deps', stock.PRICE_PATH, stock.PRICE_SHA) + clifford = stock.load(root / 'deps', stock.CLIFFORD_PATH, stock.CLIFFORD_SHA) + word = typed.authenticated(root, 'inputs/native/WORD.json.gz') + table = [clifford.canonical_frame(9, tuple(f)).tab for f in word['frames']] + inv = list(map(clifford.inverse, table)) + cosets = [stock.binary_span(x | (z << 9) for x, z, _ in q[9:]) for q in inv] + + @cache + def direction(f, g): + quotient_adjoint = clifford.compose(table[f], inv[g]) + return stock.binary_span(x for x, _, _ in quotient_adjoint[9:]) + + def moment(values): + return price.moment(values, price.TARGET) + + eligible = old['eligible_group_details'] + total_pairs = sum(len(g['members']) * (len(g['members']) - 1) for g in eligible) + assert total_pairs == 2602 + modes = ('support_no_clock', 'support_literal_window', 'support_any_original_resident', + 'support_independent_original_resident') + one = {mode: Counter() for mode in modes} + many = {mode: Counter() for mode in modes} + passed = Counter() + survivors = {mode: [] for mode in modes} + group_count = Counter() + tested = 0 + completed_groups = 0 + reason = 'ordered pair scope exhausted' + try: + first = first_observation(word, eligible, cosets, stock, time) + for group in eligible: + time() + rows = group['members'] + row_key = tuple(map(tuple, group['projective_row'])) + by_mode = {mode: [] for mode in modes} + for retained in rows: + f, g = retained['source'], retained['target'] + d = direction(f, g) + assert len(d) == retained['rank'] + residents = first[cosets[f], row_key] + born = min(residents.values()) + assert born[0] <= retained['earliest_clock'] <= retained['event'] + matched = {mode: [] for mode in modes} + for removed in rows: + if retained is removed: + continue + tested += 1 + want = direction(f, removed['target']) + if want and d != want: + continue + modes_here = [modes[0]] + if retained['earliest_clock'] <= removed['latest_clock']: + modes_here.append(modes[1]) + if born[0] <= removed['latest_clock']: + modes_here.append(modes[2]) + independent = min((candidate for role, candidate in residents.items() + if role != removed['role'] or candidate[0] <= removed['event']), + default=None) + if independent is not None and independent[0] <= removed['latest_clock']: + modes_here.append(modes[3]) + for mode in modes_here: + matched[mode].append(removed) + passed[mode] += 1 + survivors[mode].append(dict(retained=retained['event'], removed=removed['event'], + removed_rank=removed['rank'], decoder_rank=len(want), + source_observation=list(independent if mode == modes[3] else born))) + for mode in modes: + by_mode[mode].append(matched[mode]) + for mode in modes: + best = max(by_mode[mode], key=lambda rows: moment(hist(rows))[1]) + one[mode].update(hist(best)) + union_ids = {r['event'] for subset in by_mode[mode] for r in subset} + union = [r for r in rows if r['event'] in union_ids] + if len(union) == len(rows): + union.remove(min(union, key=lambda e: (e['rank'], e['event']))) + many[mode].update(hist(union)) + group_count[mode] += bool(best) + completed_groups += 1 + except TimeCap: + reason = 'time cap' + + pending = Counter() + for g in eligible[completed_groups:]: + pending.update(hist(e for e in g['members'] if e['event'] != g['retained_event'])) + upper = Q(old['baseline'][1]) + stages = old['stages'] + + def bill(values): + stage = moment(values + pending) + return dict(saving_hist=dict(values), stage_interval=list(map(str, stage)), + caller_interval=[str(stages * q) for q in stage], raw_margin_upper=str(upper + stages * stage[1])) + + return dict(status='NEGATIVE_FIXED_ONE_MONOMIAL_PER_ARM_UPPER' if Q(bill(many[modes[-1]])['raw_margin_upper']) < 0 + else 'UNRESOLVED_OR_POSITIVE_SUPPORT_UPPER', + head=old['source_head'], target=old['target'], original_stock_sha256=STOCK_SHA, + max_seconds=seconds, tested_pairs=tested, total_pairs=total_pairs, + completed_groups=completed_groups, pending_groups=len(eligible)-completed_groups, + pending_ideal_hist=dict(pending), stop_reason=reason, site_tests=0, + scope='One source monomial plus one monomial of one completed old paid child per removed target, ' + 'same exact projective input, old scalar tape, original target deadlines, and no reuse of the ' + 'removed physical output as an independently available source.', + passed_by_mode=dict(passed), eligible_groups_by_mode=dict(group_count), + price_one_retained={mode: bill(one[mode]) for mode in modes}, + price_overgrant_multiple_retained={mode: bill(many[mode]) for mode in modes}, + survivors=survivors, controls=controls()) + + +if __name__ == '__main__': + assert __debug__ + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('root', type=Path) + p.add_argument('--seconds', type=int, choices=range(1, 181), default=180) + print(json.dumps(run(**vars(p.parse_args())), indent=2, sort_keys=True)) diff --git a/research/p104-finite-monomial-decoder-bound/deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py b/research/p104-finite-monomial-decoder-bound/deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> j) & 1) << i for i, row in enumerate(matrix)) for j in range(len(matrix))) + + +def inverse(matrix): + n = len(matrix) + rows = [row | (1 << (n+i)) for i, row in enumerate(matrix)] + for j in range(n): + pivot = next((i for i in range(j, n) if rows[i] >> j & 1), None) + require(pivot is not None, 'singular binary chart') + rows[j], rows[pivot] = rows[pivot], rows[j] + for i in range(n): + if i != j and rows[i] >> j & 1: + rows[i] ^= rows[j] + require([row & ((1 << n)-1) for row in rows] == [1 << i for i in range(n)], 'binary inverse') + return tuple(row >> n for row in rows) + + +def extend(vectors, n): + columns, pivots = [], {} + for value in tuple(vectors) + tuple(1 << i for i in range(n)): + reduced = value + while reduced: + j = reduced.bit_length()-1 + if j not in pivots: + pivots[j] = reduced + columns.append(value) + break + reduced ^= pivots[j] + require(len(columns) == n, 'frame basis extension') + return tuple(columns) + + +def adjoint(circuit): + out = [] + for gate in reversed(circuit): + if gate[0] == 'P': + out.append(('P', inverse(gate[1]))) + elif gate[0] == 'D': + out.append(('D', gate[1], tuple(-a % 4 for a in gate[2]))) + elif gate[0] == 'C': + out.append(('C', gate[1], -gate[2])) + elif gate[0] == 'phase': + out.append(('phase', -gate[1] % 4)) + else: + require(gate[0] == 'X', 'adjoint gate type') + out.append(gate) + return tuple(out) + + +def fourier(rank): + return tuple(('C', 1 << i, 1) for i in range(rank)) + + +def frame(vectors, n): + rank = len(vectors) + if rank == 0: + return () + if rank == n: + return fourier(n) + matrix = transpose(extend(vectors, n)) + columns = transpose(inverse(matrix)) + quadratic = tuple((1 << i) ^ sum(parity(a & b) << j for j, b in enumerate(columns)) for i, a in enumerate(columns)) + diagonal = tuple((row >> i) & 1 for i, row in enumerate(quadratic)) + chart = (('P', matrix), ('D', quadratic, diagonal)) + return adjoint(chart) + fourier(rank) + chart + + +def monomial(record): + matrix = tuple(record['matrix_rows']) + quadratic = tuple(record['quadratic_rows']) + linear = tuple(record['linear_Z4']) + require(transpose(quadratic) == quadratic, 'quadratic symmetry') + require(len(matrix) == len(quadratic) == len(linear) == 9, 'monomial dimension') + require(all(a % 2 == (quadratic[i] >> i) & 1 for i, a in enumerate(linear)), 'diagonal parity') + inverse(matrix) + return (('D', quadratic, linear), ('P', matrix), ('X', record['offset']), ('phase', record['phase'])) + + +def recipe(record): + rank = record['rank'] + require(isinstance(rank, int) and 0 <= rank <= 9, 'child rank') + if rank == 0: + require(record['right'] is None, 'rank zero right factor') + return monomial(record['left']) + return monomial(record['right']) + fourier(rank) + monomial(record['left']) + + +def tableau(circuit, n=9): + rows = [(1 << i, 0, 0) for i in range(n)] + [(0, 1 << i, 0) for i in range(n)] + for gate in circuit: + tag = gate[0] + out = [] + inverse_transpose = transpose(inverse(gate[1])) if tag == 'P' else None + for x, z, phase in rows: + if tag == 'P': + x, z = mul(gate[1], x), mul(inverse_transpose, z) + elif tag == 'X': + phase += 2 * parity(z & gate[1]) + elif tag == 'C': + if parity(z & gate[1]): + x ^= gate[1] + phase += 3 * gate[2] + elif tag == 'D': + quadratic, linear = gate[1:] + phase += sum(linear[i] for i in range(n) if x >> i & 1) + phase += 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(n) if x >> i & 1) + z ^= mul(quadratic, x) + else: + require(tag == 'phase', 'tableau gate type') + out.append((x, z, phase % 4)) + rows = out + return tuple(rows) + + +@lru_cache(maxsize=512) +def action(gate): + if gate[0] == 'P': + return tuple(mul(gate[1], x) for x in range(512)) + require(gate[0] == 'D', 'state action type') + quadratic, linear = gate[1:] + return tuple((sum(linear[i] for i in range(9) if x >> i & 1) + + 2 * sum(parity((quadratic[i] >> (i+1)) & (x >> (i+1))) for i in range(9) if x >> i & 1)) % 4 for x in range(512)) + + +def rotate(pair, power): + a, b = pair + return ((a, b), (-b, a), (-a, -b), (b, -a))[power % 4] + + +def state(circuit, basis=0): + value, denominator = {basis: (1, 0)}, 0 + for gate in circuit: + tag = gate[0] + result = {} + if tag == "C": + direction, sign = gate[1:] + for address, (a, b) in value.items(): + for target, pair in ((address, (a - sign*b, b + sign*a)), + (address ^ direction, (a + sign*b, b - sign*a))): + old = result.get(target, (0, 0)) + result[target] = (old[0] + pair[0], old[1] + pair[1]) + denominator += 1 + else: + for address, pair in value.items(): + if tag == "P": + target = mul(gate[1], address) + elif tag == "X": + target = address ^ gate[1] + else: + target = address + if tag == "D": + pair = rotate(pair, action(gate)[address]) + else: + require(tag == "phase", "Unknown Gaussian state gate") + pair = rotate(pair, gate[1]) + require(target not in result, "A monomial address map is not injective") + result[target] = pair + value = {address: pair for address, pair in result.items() if pair != (0, 0)} + while denominator and all((a | b) % 2 == 0 for a, b in value.values()): + denominator -= 1 + value = {address: (a//2, b//2) for address, (a, b) in value.items()} + return value, denominator + + +def equal(actual, expected, label): + require(tableau(actual) == tableau(expected), label + ": signed Pauli action") + require(state(actual) == state(expected), label + ": exact global phase") + + +def verify(data, certificate): + word = data["word"] + original, clean = data["programs"], data["clean_programs"] + source_recipes = data["recipes"] + residuals = data["residuals"]["recipes"] + native_tags = {"climb", "adapter", "residual_adapter"} + for orientation in ("forward", "backward"): + native = [event for event in clean[orientation] if event[0] in native_tags] + require(native == [event for event in original[orientation] if event[0] in native_tags], + "A retained native event changed") + require(len(native) == 5056, "The retained native event count changed") + frames = [frame(tuple(vectors), 9) for vectors in word["frames"]] + used = {(event[3], event[4]) for program in clean.values() + for event in program if event[0] == "climb"} + children = {(record["old"], record["new"]): record for record in source_recipes["children"]} + require(len(children) == len(source_recipes["children"]) and used <= set(children), + "The retained child recipe coverage is incomplete") + for old, new in sorted(used): + record = children[old, new] + require(record["rank"] == len(word["frames"][new]) - len(word["frames"][old]), + "A retained child has the wrong rank") + equal(recipe(record), adjoint(frames[old]) + frames[new], "Retained child") + endpoints = {(record["role"], record["port"]): record + for record in source_recipes["endpoint_adapters"]} + require(len(endpoints) == len(source_recipes["endpoint_adapters"]) + and set(endpoints) == {(role, p) for role in ("source", "target") for p in range(112)}, + "The endpoint adapter coverage is incomplete") + for (role, port), record in endpoints.items(): + direction = word["ports"][port] + conventional = (("C", direction, 1),) if role == "source" else ( + ("C", direction, -1),) + fourier(9) + index = word["start"][port] if role == "source" else word["final"][112 + port] + require(record["frame"] == index and record["rank"] == 0, "An endpoint frame changed") + equal(recipe(record), adjoint(conventional) + frames[index], "Endpoint adapter") + used_residuals = set() + for program in clean.values(): + for event in program: + if event[0] != "residual_adapter": + continue + _, position, register, entry, *tail = event + terminal = tail[0] if tail else 1 + key = str(entry) if terminal == 1 else str(entry) + ":" + str(terminal) + require(key in residuals and position in ("pre", "post"), "A residual binding changed") + require(entry == word["start"][register] and terminal == word["final"][register], + "A residual endpoint changed") + used_residuals.add(key) + for key in sorted(used_residuals): + record = residuals[key] + equal(recipe(record), adjoint(frames[record["frame"]]) + frames[record.get("terminal", 1)], + "Residual adapter") + records = certificate["input_recipes"] + ports = certificate["compensation_ports"] + require([record["port"] for record in records] == ports and len(records) == 8, + "The eight input recipes changed") + columns = 0 + for item in records: + port, label = item["port"], item["label"] + require(label == word["ports"][port] and item["canonical_start_frame_id"] == word["start"][port], + "An input recipe has the wrong supplier label") + record = item["recipe"] + require(record["rank"] == 1, "An input copy has the wrong child rank") + for side in ("left", "right"): + factor = record[side] + require(factor["quadratic_rows"] == [0] * 9 and factor["linear_Z4"] == [0] * 9 + and factor["offset"] == factor["phase"] == 0, + "An input factor is not an address permutation") + actual, expected = recipe(record), (("C", label, 1),) + equal(actual, expected, "Positive inherited input line") + for basis in range(512): + require(state(actual, basis) == state(expected, basis), "A complete input Gaussian column differs") + columns += 1 + negative = monomial(record["right"]) + (("C", 1, -1),) + monomial(record["left"]) + require(tableau(negative) != tableau(expected) or state(negative) != state(expected), + "An inverse input child was not detected") + phased = actual + (("phase", 1),) + require(tableau(phased) == tableau(actual) and state(phased) != state(expected), + "An input phase-only error was not detected") + return {"status": "PASS_EXACT_INPUT_NATIVE_FRAMES", "retained_native_events_per_orientation": 5056, + "retained_child_recipes": len(used), "endpoint_adapter_recipes": len(endpoints), + "residual_adapter_recipes": len(used_residuals), "new_input_recipes": len(records), + "new_exact_gaussian_columns": columns, "inverse_input_child_controls": len(records), + "phase_only_controls": len(records), "address_permutation_factors": 2 * len(records), + "method": "Independent signed Pauli and exact Gaussian interpretation; no compiler import", + "scope": "Positive inherited input frames before every retained adapter. No recursive hosting claim."} diff --git a/research/p104-finite-monomial-decoder-bound/deps/round11/frontier/independent_adapter_price.py b/research/p104-finite-monomial-decoder-bound/deps/round11/frontier/independent_adapter_price.py new file mode 100644 index 0000000000..a1a291ac06 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/deps/round11/frontier/independent_adapter_price.py @@ -0,0 +1,139 @@ +"""Independent exact rank-one census and rational price separation on #7161.""" +from collections import Counter +from fractions import Fraction +from functools import cache +import gzip +from hashlib import sha256 +import json +from pathlib import Path +import sys + +TARGET = Fraction('0.0040075385047236') +PINS = { + 'peer/research/p104-rank8-exit-funded-split/WORD.json.gz': 'c1caec11ca3ee264ef03018dd91037eac10c3e28950c4c525ee1b4bf5ee210e2', + 'peer/research/p104-rank8-exit-funded-split/RESULT.json': '59080d75e7281b1a8c1353930917fd15869ad747ff4200948898f78f11c14089', + 'caller/CALLER.json': '255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', +} + + +def read(root, path): + data = (root / path).read_bytes() + if sha256(data).hexdigest() != PINS[path]: + raise ValueError(f'SHA-256 mismatch: {path}') + return json.loads(gzip.decompress(data) if path.endswith('.gz') else data) + + +def chart_span(vectors): + values = {0} + for vector in vectors: + if vector in values: + raise ValueError('dependent chart basis') + values.update(vector ^ x for x in tuple(values)) + return values + + +@cache +def reduced_log(value): + assert 1 <= value <= 2 + t = (value-1)/(value+1) + n = 30 + low = 2*sum((t**(2*j+1)/Fraction(2*j+1) for j in range(n)), Fraction(0)) + tail = 2*t**(2*n+1)/(Fraction(2*n+1)*(1-t*t)) + return low, low+tail + + +def exp_minus_bounds(value): + assert 0 <= value < 1 + terms = [Fraction(1)] + for degree in range(1,21): + terms.append(-terms[-1]*value/degree) + return sum(terms[:-1]), sum(terms) + + +@cache +def price(rank): + exponent = rank.bit_length()-1 + dyadic = Fraction(rank, 1 << exponent) + low2, high2 = reduced_log(Fraction(2)) + low, high = reduced_log(dyadic) + lower = exp_minus_bounds(TARGET*(high+exponent*high2))[0] + upper = exp_minus_bounds(TARGET*(low+exponent*low2))[1] + return rank*lower, rank*upper + + +def pair_margin(moment, delta, pairs): + return tuple(a+pairs*b for a,b in zip(moment,delta,strict=True)) + + +def encode(bounds): + scale = 10**25 + lower, upper = (entry*scale for entry in bounds) + endpoints = [lower.numerator//lower.denominator, -((-upper.numerator)//upper.denominator)] + return [str(Fraction(value, scale)) for value in endpoints] + + +def run(root): + word, result, caller = (read(root, name) for name in PINS) + spaces = [chart_span(frame) for frame in word['frames']] + main = set(word['live']) | {row+112 for row in word['live']} + main.update(word['hosted']['X2']+word['hosted']['Y2']) + native, rank_one = Counter(), Counter() + for event in word['program']: + if event[0] != 'MOVE': + continue + _, role, source, target, owned = event + a, b = spaces[source], spaces[target] + assert owned == (role >= word['public']) + assert a < b or owned and b < a + rank = abs(len(word['frames'][source])-len(word['frames'][target])) + native[rank] += 1 + if rank == 1: + rank_one['owned' if owned else 'main' if role in main else 'public_helper'] += 1 + paid, stages = Counter(), [] + for event in caller['events']: + if event[0] == 'J': + paid.update(native) + stages.append(event[1]) + continue + kind, op, _, *params = event + ports = len(caller['types'][kind]['ports']) + if op == 'QUERY': + paid[1] += ports + elif op in ('IDLE_ONE','IDLE_ODD'): + paid[8*len(params[0])+(op == 'IDLE_ODD')] += ports + assert stages == list(range(1,18)) + frozen = result['price']['after'] + assert paid == {int(k):v for k,v in frozen['P'].items()} + target = {int(k):v for k,v in frozen['T'].items()} + physical = result['checks']['ODD-PHYSICAL-BINDING.json']['occurrence_and_geometry'] + assert frozen['T'] == physical['targets'] and sum(target.values()) == 22427 + assert sum(paid.values()) == 110519 + moment = [Fraction(0), Fraction(0)] + for rank in sorted(paid.keys()|target.keys()): + count = target.get(rank,0)-paid.get(rank,0) + interval = price(rank) + if count < 0: + interval = interval[::-1] + moment = [a+count*b for a,b in zip(moment,interval,strict=True)] + two_low, two_high = price(2) + delta = 2-two_high, 2-two_low + ideal = sum(count*len(stages)//2 for count in rank_one.values()) + public_ideal = sum(rank_one[key]*len(stages)//2 for key in ('main','public_helper')) + ratio = -moment[1]/delta[1] + needed = -(-ratio.numerator//ratio.denominator) + assert ideal == 33991 and public_ideal == 33821 and needed == 25328 + prev, first = (pair_margin(moment,delta,k) for k in (needed-1,needed)) + assert prev[1] < 0 < first[0] + return {'target':str(TARGET),'pins':PINS,'native_rank_one_classes':rank_one, + 'stages':len(stages),'paid_total':sum(paid.values()), + 'productive_total':sum(target.values()),'ideal_pairs_all_native':ideal, + 'ideal_pairs_public_only':public_ideal,'minimum_ideal_pairs':needed, + 'interval_rational_scale':10**25,'baseline':encode(moment),'one_pair_credit':encode(delta), + 'before_threshold':encode(prev),'first_positive_threshold':encode(first), + 'all_native_upper':encode(pair_margin(moment,delta,ideal)), + 'public_only_upper':encode(pair_margin(moment,delta,public_ideal))} + + +if __name__ == '__main__': + assert __debug__ + print(json.dumps(run(Path(sys.argv[1])),indent=2,sort_keys=True)) diff --git a/research/p104-finite-monomial-decoder-bound/deps/round13/alternative/reprice.py b/research/p104-finite-monomial-decoder-bound/deps/round13/alternative/reprice.py new file mode 100644 index 0000000000..bbba640a1a --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/deps/round13/alternative/reprice.py @@ -0,0 +1,286 @@ +"""Recount #7161 and reprice its helper-only partition relaxation.""" +from collections import Counter +from fractions import Fraction as Q +from functools import cache +import gzip +from hashlib import sha256 +import json +from pathlib import Path +import sys + +PINS = { + "native/WORD.json.gz": "c1caec11ca3ee264ef03018dd91037eac10c3e28950c4c525ee1b4bf5ee210e2", + "native/RESULT.json": "59080d75e7281b1a8c1353930917fd15869ad747ff4200948898f78f11c14089", + "caller/CALLER.json": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", +} +TARGET = Q("0.0040075385047236") +GRID = 10**25 + + +def authenticated(root, name): + blob = (root / name).read_bytes() + if sha256(blob).hexdigest() != PINS[name]: + raise ValueError(f"SHA-256 mismatch: {name}") + return json.loads(gzip.decompress(blob) if name.endswith(".gz") else blob) + + +def span(basis): + out = {0} + for b in basis: + if b in out: + raise ValueError("dependent frame") + out |= {x ^ b for x in out} + return out + + +def invoice(w, c, result): + ranks = list(map(len, w["frames"])) + spaces = list(map(span, w["frames"])) + main_roles = [*w["live"], *(112+j for j in w["live"]), *w["hosted"]["X2"], *w["hosted"]["Y2"]] + assert len(set(main_roles)) == len(main_roles) == 400 + assert w["public"] == len(w["initial"]) == len(w["final"]) == 1499 + assert len(w["live"]) == len(w["ports"]) == 104 + assert sorted(p for d in c["types"].values() for p in d["ports"]) == list(range(104)) + assert sorted(w["hosted"]["Dports"]) == sorted(c["types"]["A"]["ports"]) + + origins = {} + visits = {} + for role,(a,b) in enumerate(zip(w["initial"], w["final"], strict=True)): + if role not in main_roles: + assert spaces[a] < spaces[b] + origins[role] = (a,b,ranks[b]-ranks[a]) + visits[role] = {a} + + paid_native = Counter() + for op,role,*rest in w["program"]: + if op == "MOVE": + a,b,owned = rest + assert owned == (role >= w["public"]) + assert spaces[a] < spaces[b] or (owned and spaces[b] < spaces[a]) + paid_native[abs(ranks[b]-ranks[a])] += 1 + if role in visits: + visits[role].add(b) + + native_stages = [e[1] for e in c["events"] if e[0]=="J"] + assert native_stages == list(range(1,c["stages"]+1)) + copies = len(native_stages) + helper_hist = Counter(r for a,b,r in origins.values()) + targets = Counter({r:copies*n for r,n in helper_hist.items()}) + paid = Counter({r:copies*n for r,n in paid_native.items()}) + fixed_main = Counter() + for spec in c["types"].values(): + ports = len(spec["ports"]) + assert len(spec["diagonal"]) == spec["roles"] + for sign,head,*body in spec["diagonal"]: + assert sign == -1 and head == 0 and len(body) == copies and set(body)<={0,1} + fixed_main[1+8*sum(body)] += ports + targets.update(fixed_main) + for event in c["events"]: + if event[0]=="J": + continue + kind,op,_,*args=event + ports=len(c["types"][kind]["ports"]) + if op=="QUERY": + paid[1] += ports + elif op in ("IDLE_ONE","IDLE_ODD"): + paid[8*len(args[0])+(op=="IDLE_ODD")] += ports + + frozen = result["price"]["after"] + observed = result["checks"]["ODD-PHYSICAL-BINDING.json"]["occurrence_and_geometry"] + for key,hist in (("P",paid),("T",targets)): + assert {str(r):n for r,n in hist.items()} == frozen[key] + assert frozen[key] == observed["paid" if key=="P" else "targets"] + assert result["caller_sha256"] == PINS["caller/CALLER.json"] + assert observed["fresh_helpers"] == copies*len(origins) + assert sum(r*(targets[r]-paid[r]) for r in targets.keys()|paid.keys()) == frozen["S"] == 1424 + return targets, paid, fixed_main, paid_native, copies, origins, visits, ranks, spaces + + +def round_q(x, upper): + y=x*GRID + n,d=y.numerator,y.denominator + return Q(-((-n)//d) if upper else n//d,GRID) + + +def round_iv(lo,hi): + return round_q(lo,False), round_q(hi,True) + + +@cache +def log_reduced(x): + z=(x-1)/(x+1) + lo=2*sum(z**(2*j+1)/(2*j+1) for j in range(31)) + return round_iv(lo,lo+2*z**63/(63*(1-z*z))) + + +@cache +def log_rank(r): + e=r.bit_length()-1 + lo,hi=log_reduced(Q(r,1<0>moment(signed,right)[1] + while right-left>Q(1,10**13): + k=(left+right)/2 + lo,hi=moment(signed,k) + if lo>0: + left=k + elif hi<0: + right=k + else: + raise ValueError("undecided bisection") + scale=10**13 + l,r=(left*scale,right*scale) + a,b=Q(l.numerator//l.denominator,scale),Q(-((-r.numerator)//r.denominator),scale) + assert moment(signed,a)[0]>0>moment(signed,b)[1] + return {"first_crossing_bracket": list(map(str,(a,b))), + "largest_derivative_upper_on_0_to_0.02": str(round_q(max(derivative_upper),True))} + + +def partition(rank,pieces): + n=min(rank,pieces) + q,r=divmod(rank,n) + return [q+1]*r+[q]*(n-r) + + +def exchange(rank, parts, copies=1): + delta=Counter({rank:-copies}) + delta.update({r:copies*n for r,n in Counter(parts).items()}) + return delta + + +def with_splits(signed, profile, copies): + out=signed.copy() + for (rank,parts),count in profile.items(): + out.update(exchange(rank,parts,copies*count)) + return out + + +def integer_room(interval): + lo,hi=interval + assert lo>0 and lo.numerator//lo.denominator==hi.numerator//hi.denominator + return lo.numerator//lo.denominator + + +def solve(root): + w,result,c=(authenticated(root,p) for p in PINS) + T,P,main,native,stages,origins,visits,ranks,spaces=invoice(w,c,result) + H=Counter(r for a,b,r in origins.values()) + assert set(H)==set(range(1,10)) + signed=T.copy() + signed.subtract(P) + base=moment(signed) + gains={r:moment(exchange(r,partition(r,2),stages)) for r in range(2,10)} + assert all(gains[r][1]1}) + maximums={} + for pieces in (1,2,9): + case=with_splits(signed,balanced_profile(pieces),stages) + maximums[pieces]={**crossing(case),"target_margin":list(map(str,moment(case)))} + minimum=next(n for n in range(1,H[9]+1) if base[0]+n*gains[9][0]>0) + prev=moment(with_splits(signed,{(9,(4,5)):minimum-1},stages)) + first=moment(with_splits(signed,{(9,(4,5)):minimum},stages)) + assert prev[1]<00: + case[4]-=stages + case[5]-=stages + case[9]+=stages + assert moment(case)[1]<0 + funded_thresholds[extras]=count + break + assert len(funded_thresholds)==7 + + def split_room(profile): + full=moment(with_splits(signed,profile,stages)) + return {"target_margin":list(map(str,full)), + "whole_caller_extra_rank_one_limit":integer_room(full), + "per_native_extra_rank_one_limit":integer_room(tuple(x/stages for x in full))} + + groups=Counter((a,b) for a,b,r in origins.values() if r==9) + assert groups=={(3,127):616} + by_id={} + direct=Counter() + balanced_nines=[] + for i,(a,b,r) in origins.items(): + cuts=sorted({ranks[f]-ranks[a] for f in visits[i] if spaces[a]{a}+{b}":n for (r,(a,b)),n in direct.items()}, + "literal_owner_all_ranks_optimistic_margin":list(map(str,cap_all)), + "scope":"Frozen main and original paid profiles except explicitly added rank-one jobs. Balanced arithmetic is an optimistic relaxation. Literal-owner ceiling requires the same original owner to visit a strict intermediate frame, with no virtual rebase or paid itinerary changes.", + } + + +if __name__=="__main__": + assert __debug__, "run without -O" + print(json.dumps(solve(Path(sys.argv[1])),sort_keys=True,indent=2)) diff --git a/research/p104-finite-monomial-decoder-bound/deps/round20/complex-stock/stock.py b/research/p104-finite-monomial-decoder-bound/deps/round20/complex-stock/stock.py new file mode 100644 index 0000000000..db36d1043b --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/deps/round20/complex-stock/stock.py @@ -0,0 +1,329 @@ +"""Exact original MOVE stock by normalized row, chart, role and clock.""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +from hashlib import sha256 +from importlib.util import module_from_spec, spec_from_file_location +from pathlib import Path +from time import monotonic +import argparse +import json +import sys + + +PRICE_PATH = 'round13/alternative/reprice.py' +PRICE_SHA = '97f4524d11a08cd3a09ceb9abc6b90f45ca579ac1c529a176b80a67201ecd90a' +SOURCE_HEAD = 'e3f8d39c43b07063dfc5b800f71c5d21015259e6' +SOURCE_TREE = '6678a6718f29a2da57efa3e748fa8ba997f6a46c' +CLIFFORD_PATH = 'canonical/research/shared-wire-split-composition/frozen/clifford_exact.py' +CLIFFORD_SHA = '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' + + +def load(deps, relative, expected): + path = deps / relative + if sha256(path.read_bytes()).hexdigest() != expected: + raise ValueError(f'SHA-256 mismatch: {relative}') + spec = spec_from_file_location(path.stem, path) + price = module_from_spec(spec) + sys.modules[spec.name] = price + spec.loader.exec_module(price) + return price + + +def scale(a, c): + return a if c == 1 else {i: c * x for i, x in a.items() if c * x} + + +def add(a, b, c): + result = a.copy() + for j, x in b.items(): + if z := result.get(j, 0) + c * x: + result[j] = z + else: + result.pop(j, None) + return result + + +def insert(basis, row): + x = row + while x: + p = min(x) + if p not in basis: + basis[p] = scale(x, 1 / x[p]) + return True + x = add(x, basis[p], -x[p]) + return False + + +def key(row): + return tuple((i, str(v)) for i, v in sorted(row.items())) + + +def proportional(row): + return key(scale(row, 1 / row[min(row)])) if row else () + + +def sweep(word, spaces, ranks, cap, seconds): + p = word['public'] + n = len(word['program']) + at = [*word['initial'], *([None] * word['owned_fields'])] + rows = [{i: Q(1)} for i in range(p)] + [{} for _ in range(word['owned_fields'])] + representative = {frozenset(s): f for f, s in reversed(list(enumerate(spaces)))} + aliases = [representative[frozenset(s)] for s in spaces] + last = [-1] * len(at) + recent = [None] * len(at) + open_chain = [[] for _ in at] + chains = [] + stock = [] + began = monotonic() + + def close(j, t): + if recent[j] is not None: + recent[j]['latest_clock'] = t + recent[j] = None + + def flush(j): + if open_chain[j]: + chains.append(open_chain[j]) + open_chain[j] = [] + + reason = 'literal scope exhausted' + for t, (op, j, *a) in enumerate(word['program']): + if t % 128 == 0 and monotonic() - began >= seconds: + reason = 'time cap' + break + if op == 'MOVE': + if len(stock) == cap: + reason = 'MOVE cap' + break + f, g, own = a + assert at[j] == f and own == (j >= p) + assert spaces[f] < spaces[g] or (own and spaces[g] < spaces[f]) + close(j, t) + record = dict(event=t, role=j, owned=own, source=f, target=g, + canonical_source=aliases[f], canonical_target=aliases[g], + rank=abs(ranks[f] - ranks[g]), row=rows[j], + earliest_clock=last[j] + 1, latest_clock=n) + stock.append(record) + recent[j] = record + open_chain[j].append(record) + at[j] = g + last[j] = t + continue + touched = (j, a[0]) if op in ('ADD', 'COPY') else (j,) + for role in touched: + close(role, t) + flush(role) + last[role] = t + if op == 'ADD': + assert at[j] == at[a[0]] == a[-1] + rows[j] = add(rows[j], rows[a[0]], Q(a[1])) + elif op == 'COPY': + assert at[j] == at[a[0]] == a[-1] and not rows[j] + rows[j] = scale(rows[a[0]], Q(a[1])) + elif op == 'SCALE': + assert at[j] == a[-1] + rows[j] = scale(rows[j], Q(a[0])) + else: + assert op in ('INIT', 'CLEAR') and j >= p + assert at[j] == (None if op == 'INIT' else a[0]) + at[j] = a[0] if op == 'INIT' else None + rows[j] = {} + if reason == 'literal scope exhausted': + assert at == [*word['final'], *([None] * word['owned_fields'])] + for j in range(len(at)): + flush(j) + assert sum(map(len, chains)) == len(stock) + return stock, chains, reason + + +def classes(rows, field): + groups = defaultdict(list) + for row in rows: + groups[field(row)].append(row) + return groups + + +def summary(groups, digest=False): + report = [] + for group, rows in sorted(groups.items()): + basis = {} + kept = [] + for row in rows: + if insert(basis, row['row']): + kept.append(row['event']) + label = sha256(json.dumps(group, separators=(',', ':')).encode()).hexdigest() if digest else group + report.append(dict(group=label, count=len(rows), basis_size=len(basis), basis_events=kept, + rank=rows[0]['rank'])) + return report + + +def binary_span(rows): + basis = {} + for x in rows: + for p, y in sorted(basis.items(), reverse=True): + if x & (1 << p): + x ^= y + if not x: + continue + p = x.bit_length() - 1 + for q, y in basis.items(): + if y & (1 << p): + basis[q] = y ^ x + basis[p] = x + return tuple(v for _, v in sorted(basis.items())) + + +def physical_classes(clifford, frames, stock): + tables = [clifford.canonical_frame(9, tuple(frame)).tab for frame in frames] + inverses = list(map(clifford.inverse, tables)) + cosets = [binary_span(x | (z << 9) for x, z, _ in inv[9:]) for inv in inverses] + signed = {} + for row in stock: + f, g, r = row['source'], row['target'], row['rank'] + if (f, g) not in signed: + table = clifford.compose(tables[g], inverses[f]) + assert clifford.rank(x for x, _, _ in table[9:]) == r + signed[f, g] = table + return classes(stock, lambda row: signed[row['source'], row['target']]), classes(stock, lambda row: cosets[row['target']]) + + +def cost_basis(groups, clock_order): + discarded = [] + chosen = 0 + for rows in groups.values(): + order = sorted(rows, key=(lambda x: x['event']) if clock_order else (lambda x: (x['rank'], x['event']))) + basis = {} + for row in order: + if insert(basis, row['row']): + chosen += 1 + else: + discarded.append(row) + return discarded, chosen + + +def hist(rows): + return Counter(r['rank'] for r in rows) + + +def difference(rows, report): + billed = Counter() + for row in report: + billed[row['rank']] += row['basis_size'] + result = hist(rows) + result.subtract(billed) + assert all(v >= 0 for v in result.values()) + return result + + +def span_order(a, b): + return a <= b or b <= a + + +def controls(): + p = {1: Q(1)} + q = {2: Q(1)} + b = {} + assert insert(b, p) and insert(b, q) + assert not insert(b, {1: Q(-2), 2: Q(3)}) + assert not insert(b, {}) + assert proportional({1: Q(7)}) == proportional({1: Q(-3)}) + assert proportional(p) != proportional(q) + return dict(independent_pair_charged_twice=True, arbitrary_linear_dependence_charged_twice=True, + exact_zero_unbilled=True, signed_proportional=True) + + +def run(inputs, deps, cap, seconds): + assert __debug__ + price = load(deps, PRICE_PATH, PRICE_SHA) + clifford = load(deps, CLIFFORD_PATH, CLIFFORD_SHA) + w, result, caller = (price.authenticated(inputs, k) for k in price.PINS) + target, paid, _, native, stages, _, _, ranks, spaces = price.invoice(w, caller, result) + assert sum(native.values()) == 6279 and stages == 17 + stock, chains, reason = sweep(w, spaces, ranks, cap, seconds) + literal = classes(stock, lambda row: (row['source'], row['target'], row['rank'])) + canonical = classes(stock, lambda row: (row['canonical_source'], row['canonical_target'], row['rank'])) + literal_report = summary(literal) + canonical_report = summary(canonical) + quotient, cosets = physical_classes(clifford, w['frames'], stock) + quotient_report = summary(quotient, digest=True) + discarded_optimistic, target_rank = cost_basis(cosets, False) + discarded_chronological, chronological_rank = cost_basis(cosets, True) + assert target_rank == chronological_rank + compound = [chain for chain in chains if len(chain) > 1] + single = [chain[0] for chain in chains if len(chain) == 1] + serial = [] + serial_hist = Counter() + serial_relax_hist = Counter() + for chain in compound: + first, last = chain[0], chain[-1] + assert all(a['target'] == b['source'] for a, b in zip(chain, chain[1:])) + assert all(first['row'] == row['row'] for row in chain) + f, g = first['source'], last['target'] + comparable = span_order(spaces[f], spaces[g]) + assumed_rank = abs(ranks[f] - ranks[g]) if comparable else 0 + gain = hist(chain) + if assumed_rank: + gain[assumed_rank] -= 1 + serial_hist.update(gain) + serial_relax_hist.update(hist(chain)) + serial.append(dict(events=[r['event'] for r in chain], role=first['role'], + first_chart=f, last_chart=g, owned=first['owned'], comparable=comparable, + direct_assumed_rank=assumed_rank, literal_identity=(f == g), + original_ranks=[r['rank'] for r in chain])) + old_h = target.copy() + old_h.subtract(paid) + moment = lambda h: price.dot(h, lambda r: price.power(r, price.TARGET)) + baseline = moment(old_h) + pending = native.copy() + pending.subtract(hist(stock)) + assert all(v >= 0 for v in pending.values()) + + def bill(saved): + h = saved.copy() + h.update(pending) + stage = moment(h) + return dict(saving_hist={r: n for r, n in sorted(saved.items()) if n}, + stage_interval=list(map(str, stage)), caller_interval=[str(stages * q) for q in stage], + target_upper=str(baseline[1] + stages * stage[1])) + + same_map = difference(stock, canonical_report) + literal_map = difference(stock, literal_report) + same_quotient = difference(stock, quotient_report) + single_events = {row['event'] for row in single} + single_quotients = {q: [r for r in rows if r['event'] in single_events] for q, rows in quotient.items()} + single_report = summary({q: rows for q, rows in single_quotients.items() if rows}) + combined = serial_relax_hist.copy() + combined.update(difference(single, single_report)) + zero = [r['event'] for r in stock if not r['row']] + return dict(source_head=SOURCE_HEAD, source_tree=SOURCE_TREE, target=str(price.TARGET), + pins={PRICE_PATH: PRICE_SHA, CLIFFORD_PATH: CLIFFORD_SHA, + **{f'public/{k}': v for k, v in price.PINS.items()}}, + cap=dict(moves=cap, seconds=seconds), reason=reason, pending_moves=sum(pending.values()), + native_moves=len(stock), stages=stages, paid_positions=sum(paid.values()), + productive_targets=sum(target.values()), stage_deficit_upper=str(-baseline[0] / stages), + baseline=list(map(str, baseline)), literal_classes=len(literal), canonical_classes=len(canonical), + signed_quotient_classes=len(quotient), target_monomial_cosets=len(cosets), + class_report=dict(literal=literal_report, canonical=canonical_report, signed_quotient=quotient_report), + prices=dict(literal_identical_all_clock=bill(literal_map), + canonical_identical_all_clock=bill(same_map), + signed_quotient_phase_free_all_clock=bill(same_quotient), + adjacent_serial_direct_quotient=bill(serial_hist), + combined_chains_granted_free_and_singleton_quotients=bill(combined), + target_coset_minimum_paid_basis=bill(hist(discarded_optimistic)), + target_coset_chronological_basis=bill(hist(discarded_chronological))), + target_coset_basis_size=target_rank, + target_coset_all_clock_discarded=[r['event'] for r in discarded_optimistic], + target_coset_chronological_discarded=[r['event'] for r in discarded_chronological], + zero_rows=zero, serial_runs=serial, controls=controls(), site_tests=0, + stock=[{**{k: v for k, v in r.items() if k != 'row'}, 'row_support': len(r['row']), + 'row_sha256': sha256(json.dumps(key(r['row']), separators=(',', ':')).encode()).hexdigest()} + for r in stock]) + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + for name in ('inputs', 'deps'): + p.add_argument(name, type=Path) + p.add_argument('--cap', type=int, choices=range(1, 6280), default=6279) + p.add_argument('--seconds', type=int, choices=range(1, 601), default=600) + print(json.dumps(run(**vars(p.parse_args())), indent=2, sort_keys=True)) diff --git a/research/p104-finite-monomial-decoder-bound/inputs/caller/CALLER.json b/research/p104-finite-monomial-decoder-bound/inputs/caller/CALLER.json new file mode 100644 index 0000000000..9451ceaf6e --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/inputs/caller/CALLER.json @@ -0,0 +1 @@ +{"schema":"mixed-root-caller/1","stages":17,"ambient_rank":145,"roles":72,"types":{"A":{"form":"two-chain-HOST2","roles":36,"offset":0,"ports":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,18,19,20,21,22,23,24,25,26,28,29,30,31,32,33,36,37,38,39,40,41,43,44,45,46,48,49,50,51,52,53,54,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103],"alpha2":"-1","beta2":"0","diagonal":[[-1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[-1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1],[-1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[-1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1]]},"B":{"form":"hosted-HOST","roles":36,"offset":36,"ports":[15,17,27,34,35,42,47,55],"diagonal":[[-1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[-1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[-1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0],[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]],"pairs":[[0,1,"-1","1/2","-1/2"],[2,3,"-1","1/2","-1/2"],[4,5,"-1","1/2","-1/2"],[6,7,"-1","1/2","-1/2"],[8,9,"-1","1/2","-1/2"],[10,11,"-1","1/2","-1/2"],[12,13,"-1","1/2","-1/2"],[14,15,"-1","1/2","-1/2"],[16,17,"-1","1/2","-1/2"],[22,23,"-1","1/2","-1/2"],[24,25,"-1","1/2","-1/2"],[26,27,"-1","1/2","-1/2"],[28,29,"-1","1/2","-1/2"],[30,31,"-1","1/2","-1/2"],[32,33,"-1","1/2","-1/2"],[34,35,"-1","1/2","-1/2"],[36,37,"-1","1/2","-1/2"],[38,39,"-1","1/2","-1/2"]]}},"events":[["B","ADD",37,36,"7"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"1"],["B","ADD",36,38,"2"],["B","ADD",36,39,"-2"],["B","IDLE_ONE",36,[1]],["B","ADD",36,39,"2"],["B","ADD",36,38,"-2"],["B","ADD",36,37,"-1"],["B","SCALE",36,"-1/2"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-7"],["B","ADD",39,37,"-1/2"],["B","SCALE",37,"-2"],["B","ADD",37,38,"4"],["B","ADD",37,39,"-8"],["B","IDLE_ONE",37,[1]],["B","ADD",37,39,"8"],["B","ADD",37,38,"-4"],["B","SCALE",37,"-1/2"],["B","ADD",39,37,"1/2"],["B","ADD",37,36,"1"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",38,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,38,"2"],["B","ADD",37,39,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",1,"-1"],["A","ADD",1,0,"1"],["A","ADD",19,18,"-1"],["A","SCALE",19,"-1"],["A","LAMBDA",1,1],["A","LAMBDA",19,-1],["A","SCALE",19,"-1"],["J",1,[1,0,18,19],[36,37,"-1","1/2"]],["A","LAMBDA",1,-1],["A","LAMBDA",19,1],["A","SCALE",19,"-1"],["A","ADD",0,1,"-1"],["A","ADD",18,19,"-1"],["A","SCALE",19,"-1"],["A","ADD",19,18,"1"],["A","ADD",1,0,"-1"],["A","SCALE",1,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,39,"1"],["B","ADD",37,38,"-2"],["B","SCALE",37,"-2"],["B","ADD",38,37,"-1/2"],["B","ADD",36,38,"1"],["B","ADD",39,36,"-1/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"12/5"],["B","ADD",38,36,"1/5"],["B","ADD",39,36,"3/10"],["B","ADD",40,36,"-1/40"],["B","ADD",41,36,"3/40"],["B","SCALE",36,"-1/10"],["B","ADD",36,37,"-1"],["B","ADD",36,38,"-2"],["B","ADD",36,39,"6"],["B","ADD",36,40,"20"],["B","ADD",36,41,"8"],["B","IDLE_ONE",36,[2]],["B","ADD",36,41,"-8"],["B","ADD",36,40,"-20"],["B","ADD",36,39,"-6"],["B","ADD",36,38,"2"],["B","ADD",36,37,"1"],["B","SCALE",36,"-10"],["B","ADD",41,36,"-3/40"],["B","ADD",40,36,"1/40"],["B","ADD",39,36,"-3/10"],["B","ADD",38,36,"-1/5"],["B","ADD",37,36,"-12/5"],["B","ADD",37,36,"7/3"],["B","ADD",38,36,"1/6"],["B","ADD",39,36,"1/6"],["B","ADD",41,36,"1/12"],["B","SCALE",36,"1/3"],["B","ADD",36,37,"-2"],["B","ADD",36,38,"-8"],["B","ADD",36,39,"20"],["B","ADD",36,40,"68"],["B","ADD",36,41,"28"],["B","IDLE_ONE",36,[2]],["B","ADD",36,41,"-28"],["B","ADD",36,40,"-68"],["B","ADD",36,39,"-20"],["B","ADD",36,38,"8"],["B","ADD",36,37,"2"],["B","SCALE",36,"3"],["B","ADD",41,36,"-1/12"],["B","ADD",39,36,"-1/6"],["B","ADD",38,36,"-1/6"],["B","ADD",37,36,"-7/3"],["B","ADD",37,36,"3"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"3/2"],["B","ADD",40,36,"-1/2"],["B","ADD",41,36,"1/2"],["B","SCALE",36,"-1"],["B","ADD",36,37,"1/2"],["B","ADD",36,39,"-1"],["B","ADD",36,40,"-4"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,38,"1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-8"],["B","ADD",37,41,"-4"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",2,"-1"],["A","ADD",2,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-1"],["A","SCALE",20,"-1"],["A","LAMBDA",2,1],["A","LAMBDA",20,-1],["A","SCALE",20,"-1"],["J",2,[2,0,18,20],[36,37,"-1","1/2"]],["A","LAMBDA",2,-1],["A","LAMBDA",20,1],["A","SCALE",20,"-1"],["A","ADD",0,2,"-1"],["A","ADD",18,20,"-1"],["A","SCALE",20,"-1"],["A","ADD",20,18,"1"],["A","ADD",19,18,"2"],["A","ADD",1,0,"2"],["A","ADD",2,0,"-1"],["A","SCALE",2,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,41,"4"],["B","ADD",37,40,"8"],["B","ADD",37,39,"2"],["B","ADD",37,38,"-1"],["B","SCALE",37,"2"],["B","ADD",40,37,"-1/2"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,40,"4"],["B","ADD",36,39,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-1"],["B","ADD",41,36,"-1/2"],["B","ADD",40,36,"1/2"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"7"],["B","ADD",38,36,"5/2"],["B","ADD",39,36,"19/2"],["B","ADD",40,36,"-5/4"],["B","ADD",41,36,"-9/4"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"7"],["B","ADD",36,38,"26"],["B","ADD",36,39,"-66"],["B","ADD",36,40,"-212"],["B","ADD",36,41,"-132"],["B","ADD",36,42,"14"],["B","ADD",36,43,"-26"],["B","IDLE_ONE",36,[3]],["B","ADD",36,43,"26"],["B","ADD",36,42,"-14"],["B","ADD",36,41,"132"],["B","ADD",36,40,"212"],["B","ADD",36,39,"66"],["B","ADD",36,38,"-26"],["B","ADD",36,37,"-7"],["B","SCALE",36,"-1/2"],["B","ADD",43,36,"-3/2"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"9/4"],["B","ADD",40,36,"5/4"],["B","ADD",39,36,"-19/2"],["B","ADD",38,36,"-5/2"],["B","ADD",37,36,"-7"],["B","ADD",37,36,"22/3"],["B","ADD",38,36,"8/3"],["B","ADD",39,36,"61/6"],["B","ADD",40,36,"-4/3"],["B","ADD",41,36,"-29/12"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"5/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"2"],["B","ADD",36,38,"8"],["B","ADD",36,39,"-20"],["B","ADD",36,40,"-64"],["B","ADD",36,41,"-40"],["B","ADD",36,42,"4"],["B","ADD",36,43,"-8"],["B","IDLE_ONE",36,[3]],["B","ADD",36,43,"8"],["B","ADD",36,42,"-4"],["B","ADD",36,41,"40"],["B","ADD",36,40,"64"],["B","ADD",36,39,"20"],["B","ADD",36,38,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"3/2"],["B","ADD",43,36,"-5/3"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"29/12"],["B","ADD",40,36,"4/3"],["B","ADD",39,36,"-61/6"],["B","ADD",38,36,"-8/3"],["B","ADD",37,36,"-22/3"],["B","ADD",37,36,"1"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"-5/2"],["B","ADD",40,36,"1/4"],["B","ADD",41,36,"3/4"],["B","ADD",42,36,"1/2"],["B","ADD",43,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",36,39,"2"],["B","ADD",36,40,"6"],["B","ADD",36,41,"4"],["B","ADD",36,42,"-1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,39,"-1"],["B","ADD",37,40,"-4"],["B","ADD",37,41,"-2"],["B","ADD",37,42,"2"],["B","ADD",37,43,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",3,"-1"],["A","ADD",3,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-1"],["A","SCALE",21,"-1"],["A","LAMBDA",3,1],["A","LAMBDA",21,-1],["A","SCALE",21,"-1"],["J",3,[3,0,18,21],[36,37,"-1","1/2"]],["A","LAMBDA",3,-1],["A","LAMBDA",21,1],["A","SCALE",21,"-1"],["A","ADD",0,3,"-1"],["A","ADD",18,21,"-1"],["A","SCALE",21,"-1"],["A","ADD",21,18,"1"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",3,0,"-1"],["A","SCALE",3,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,43,"1"],["B","ADD",37,42,"-2"],["B","ADD",37,41,"2"],["B","ADD",37,40,"4"],["B","ADD",37,39,"1"],["B","SCALE",37,"-2"],["B","ADD",42,37,"-1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,42,"1"],["B","ADD",36,41,"-4"],["B","ADD",36,40,"-6"],["B","ADD",36,39,"-2"],["B","ADD",36,38,"1"],["B","ADD",43,36,"-1/2"],["B","ADD",42,36,"-1/2"],["B","ADD",41,36,"-3/4"],["B","ADD",40,36,"-1/4"],["B","ADD",39,36,"5/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"12/5"],["B","ADD",38,36,"1/5"],["B","ADD",39,36,"3/10"],["B","ADD",40,36,"-1/10"],["B","ADD",41,36,"1/20"],["B","ADD",42,36,"1/5"],["B","ADD",43,36,"3/10"],["B","ADD",44,36,"-1/40"],["B","ADD",45,36,"3/40"],["B","SCALE",36,"-1/10"],["B","ADD",36,37,"-1"],["B","ADD",36,38,"-2"],["B","ADD",36,39,"6"],["B","ADD",36,40,"20"],["B","ADD",36,41,"12"],["B","ADD",36,42,"-2"],["B","ADD",36,43,"6"],["B","ADD",36,44,"20"],["B","ADD",36,45,"8"],["B","IDLE_ONE",36,[4]],["B","ADD",36,45,"-8"],["B","ADD",36,44,"-20"],["B","ADD",36,43,"-6"],["B","ADD",36,42,"2"],["B","ADD",36,41,"-12"],["B","ADD",36,40,"-20"],["B","ADD",36,39,"-6"],["B","ADD",36,38,"2"],["B","ADD",36,37,"1"],["B","SCALE",36,"-10"],["B","ADD",45,36,"-3/40"],["B","ADD",44,36,"1/40"],["B","ADD",43,36,"-3/10"],["B","ADD",42,36,"-1/5"],["B","ADD",41,36,"-1/20"],["B","ADD",40,36,"1/10"],["B","ADD",39,36,"-3/10"],["B","ADD",38,36,"-1/5"],["B","ADD",37,36,"-12/5"],["B","ADD",37,36,"7/3"],["B","ADD",38,36,"1/6"],["B","ADD",39,36,"1/6"],["B","ADD",40,36,"-1/12"],["B","ADD",41,36,"1/12"],["B","ADD",42,36,"1/6"],["B","ADD",43,36,"1/6"],["B","ADD",45,36,"1/12"],["B","SCALE",36,"1/3"],["B","ADD",36,37,"-2"],["B","ADD",36,38,"-8"],["B","ADD",36,39,"20"],["B","ADD",36,40,"64"],["B","ADD",36,41,"40"],["B","ADD",36,42,"-8"],["B","ADD",36,43,"20"],["B","ADD",36,44,"68"],["B","ADD",36,45,"28"],["B","IDLE_ONE",36,[4]],["B","ADD",36,45,"-28"],["B","ADD",36,44,"-68"],["B","ADD",36,43,"-20"],["B","ADD",36,42,"8"],["B","ADD",36,41,"-40"],["B","ADD",36,40,"-64"],["B","ADD",36,39,"-20"],["B","ADD",36,38,"8"],["B","ADD",36,37,"2"],["B","SCALE",36,"3"],["B","ADD",45,36,"-1/12"],["B","ADD",43,36,"-1/6"],["B","ADD",42,36,"-1/6"],["B","ADD",41,36,"-1/12"],["B","ADD",40,36,"1/12"],["B","ADD",39,36,"-1/6"],["B","ADD",38,36,"-1/6"],["B","ADD",37,36,"-7/3"],["B","ADD",37,36,"3"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"3/2"],["B","ADD",40,36,"-1/4"],["B","ADD",41,36,"-1/4"],["B","ADD",42,36,"1/2"],["B","ADD",43,36,"3/2"],["B","ADD",44,36,"-1/2"],["B","ADD",45,36,"1/2"],["B","SCALE",36,"-1"],["B","ADD",36,37,"1/2"],["B","ADD",36,39,"-1"],["B","ADD",36,40,"-4"],["B","ADD",36,41,"-2"],["B","ADD",36,43,"-1"],["B","ADD",36,44,"-4"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,38,"1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-6"],["B","ADD",37,41,"-4"],["B","ADD",37,42,"1"],["B","ADD",37,43,"-2"],["B","ADD",37,44,"-8"],["B","ADD",37,45,"-4"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",4,"-1"],["A","ADD",4,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-1"],["A","SCALE",22,"-1"],["A","LAMBDA",4,1],["A","LAMBDA",22,-1],["A","SCALE",22,"-1"],["J",4,[4,0,18,22],[36,37,"-1","1/2"]],["A","LAMBDA",4,-1],["A","LAMBDA",22,1],["A","SCALE",22,"-1"],["A","ADD",0,4,"-1"],["A","ADD",18,22,"-1"],["A","SCALE",22,"-1"],["A","ADD",22,18,"1"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",4,0,"-1"],["A","SCALE",4,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,45,"4"],["B","ADD",37,44,"8"],["B","ADD",37,43,"2"],["B","ADD",37,42,"-1"],["B","ADD",37,41,"4"],["B","ADD",37,40,"6"],["B","ADD",37,39,"2"],["B","ADD",37,38,"-1"],["B","SCALE",37,"2"],["B","ADD",44,37,"-1/2"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,44,"4"],["B","ADD",36,43,"1"],["B","ADD",36,41,"2"],["B","ADD",36,40,"4"],["B","ADD",36,39,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-1"],["B","ADD",45,36,"-1/2"],["B","ADD",44,36,"1/2"],["B","ADD",43,36,"-3/2"],["B","ADD",42,36,"-1/2"],["B","ADD",41,36,"1/4"],["B","ADD",40,36,"1/4"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"7"],["B","ADD",38,36,"5/2"],["B","ADD",39,36,"19/2"],["B","ADD",40,36,"-5/4"],["B","ADD",41,36,"-9/4"],["B","ADD",42,36,"5/2"],["B","ADD",43,36,"19/2"],["B","ADD",44,36,"-5/4"],["B","ADD",45,36,"-9/4"],["B","ADD",46,36,"-1/2"],["B","ADD",47,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"7"],["B","ADD",36,38,"26"],["B","ADD",36,39,"-66"],["B","ADD",36,40,"-212"],["B","ADD",36,41,"-132"],["B","ADD",36,42,"26"],["B","ADD",36,43,"-66"],["B","ADD",36,44,"-212"],["B","ADD",36,45,"-132"],["B","ADD",36,46,"14"],["B","ADD",36,47,"-26"],["B","IDLE_ONE",36,[5]],["B","ADD",36,47,"26"],["B","ADD",36,46,"-14"],["B","ADD",36,45,"132"],["B","ADD",36,44,"212"],["B","ADD",36,43,"66"],["B","ADD",36,42,"-26"],["B","ADD",36,41,"132"],["B","ADD",36,40,"212"],["B","ADD",36,39,"66"],["B","ADD",36,38,"-26"],["B","ADD",36,37,"-7"],["B","SCALE",36,"-1/2"],["B","ADD",47,36,"-3/2"],["B","ADD",46,36,"1/2"],["B","ADD",45,36,"9/4"],["B","ADD",44,36,"5/4"],["B","ADD",43,36,"-19/2"],["B","ADD",42,36,"-5/2"],["B","ADD",41,36,"9/4"],["B","ADD",40,36,"5/4"],["B","ADD",39,36,"-19/2"],["B","ADD",38,36,"-5/2"],["B","ADD",37,36,"-7"],["B","ADD",37,36,"22/3"],["B","ADD",38,36,"8/3"],["B","ADD",39,36,"61/6"],["B","ADD",40,36,"-4/3"],["B","ADD",41,36,"-29/12"],["B","ADD",42,36,"8/3"],["B","ADD",43,36,"61/6"],["B","ADD",44,36,"-4/3"],["B","ADD",45,36,"-29/12"],["B","ADD",46,36,"-1/2"],["B","ADD",47,36,"5/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"2"],["B","ADD",36,38,"8"],["B","ADD",36,39,"-20"],["B","ADD",36,40,"-64"],["B","ADD",36,41,"-40"],["B","ADD",36,42,"8"],["B","ADD",36,43,"-20"],["B","ADD",36,44,"-64"],["B","ADD",36,45,"-40"],["B","ADD",36,46,"4"],["B","ADD",36,47,"-8"],["B","IDLE_ONE",36,[5]],["B","ADD",36,47,"8"],["B","ADD",36,46,"-4"],["B","ADD",36,45,"40"],["B","ADD",36,44,"64"],["B","ADD",36,43,"20"],["B","ADD",36,42,"-8"],["B","ADD",36,41,"40"],["B","ADD",36,40,"64"],["B","ADD",36,39,"20"],["B","ADD",36,38,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"3/2"],["B","ADD",47,36,"-5/3"],["B","ADD",46,36,"1/2"],["B","ADD",45,36,"29/12"],["B","ADD",44,36,"4/3"],["B","ADD",43,36,"-61/6"],["B","ADD",42,36,"-8/3"],["B","ADD",41,36,"29/12"],["B","ADD",40,36,"4/3"],["B","ADD",39,36,"-61/6"],["B","ADD",38,36,"-8/3"],["B","ADD",37,36,"-22/3"],["B","ADD",37,36,"1"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"-5/2"],["B","ADD",40,36,"1/4"],["B","ADD",41,36,"3/4"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"-5/2"],["B","ADD",44,36,"1/4"],["B","ADD",45,36,"3/4"],["B","ADD",46,36,"1/2"],["B","ADD",47,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",36,39,"2"],["B","ADD",36,40,"6"],["B","ADD",36,41,"4"],["B","ADD",36,42,"-1"],["B","ADD",36,43,"2"],["B","ADD",36,44,"6"],["B","ADD",36,45,"4"],["B","ADD",36,46,"-1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,39,"-1"],["B","ADD",37,40,"-4"],["B","ADD",37,41,"-2"],["B","ADD",37,43,"-1"],["B","ADD",37,44,"-4"],["B","ADD",37,45,"-2"],["B","ADD",37,46,"2"],["B","ADD",37,47,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",5,"-1"],["A","ADD",5,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-1"],["A","SCALE",23,"-1"],["A","LAMBDA",5,1],["A","LAMBDA",23,-1],["A","SCALE",23,"-1"],["J",5,[5,0,18,23],[36,37,"-1","1/2"]],["A","LAMBDA",5,-1],["A","LAMBDA",23,1],["A","SCALE",23,"-1"],["A","ADD",0,5,"-1"],["A","ADD",18,23,"-1"],["A","SCALE",23,"-1"],["A","ADD",23,18,"1"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",5,0,"-1"],["A","SCALE",5,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,47,"1"],["B","ADD",37,46,"-2"],["B","ADD",37,45,"2"],["B","ADD",37,44,"4"],["B","ADD",37,43,"1"],["B","ADD",37,41,"2"],["B","ADD",37,40,"4"],["B","ADD",37,39,"1"],["B","SCALE",37,"-2"],["B","ADD",46,37,"-1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,46,"1"],["B","ADD",36,45,"-4"],["B","ADD",36,44,"-6"],["B","ADD",36,43,"-2"],["B","ADD",36,42,"1"],["B","ADD",36,41,"-4"],["B","ADD",36,40,"-6"],["B","ADD",36,39,"-2"],["B","ADD",36,38,"1"],["B","ADD",47,36,"-1/2"],["B","ADD",46,36,"-1/2"],["B","ADD",45,36,"-3/4"],["B","ADD",44,36,"-1/4"],["B","ADD",43,36,"5/2"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"-3/4"],["B","ADD",40,36,"-1/4"],["B","ADD",39,36,"5/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"12/5"],["B","ADD",38,36,"1/5"],["B","ADD",39,36,"3/10"],["B","ADD",40,36,"-1/10"],["B","ADD",41,36,"1/20"],["B","ADD",42,36,"1/5"],["B","ADD",43,36,"3/10"],["B","ADD",44,36,"-1/10"],["B","ADD",45,36,"1/20"],["B","ADD",46,36,"1/5"],["B","ADD",47,36,"3/10"],["B","ADD",48,36,"-1/40"],["B","ADD",49,36,"3/40"],["B","SCALE",36,"-1/10"],["B","ADD",36,37,"-1"],["B","ADD",36,38,"-2"],["B","ADD",36,39,"6"],["B","ADD",36,40,"20"],["B","ADD",36,41,"12"],["B","ADD",36,42,"-2"],["B","ADD",36,43,"6"],["B","ADD",36,44,"20"],["B","ADD",36,45,"12"],["B","ADD",36,46,"-2"],["B","ADD",36,47,"6"],["B","ADD",36,48,"20"],["B","ADD",36,49,"8"],["B","IDLE_ONE",36,[6]],["B","ADD",36,49,"-8"],["B","ADD",36,48,"-20"],["B","ADD",36,47,"-6"],["B","ADD",36,46,"2"],["B","ADD",36,45,"-12"],["B","ADD",36,44,"-20"],["B","ADD",36,43,"-6"],["B","ADD",36,42,"2"],["B","ADD",36,41,"-12"],["B","ADD",36,40,"-20"],["B","ADD",36,39,"-6"],["B","ADD",36,38,"2"],["B","ADD",36,37,"1"],["B","SCALE",36,"-10"],["B","ADD",49,36,"-3/40"],["B","ADD",48,36,"1/40"],["B","ADD",47,36,"-3/10"],["B","ADD",46,36,"-1/5"],["B","ADD",45,36,"-1/20"],["B","ADD",44,36,"1/10"],["B","ADD",43,36,"-3/10"],["B","ADD",42,36,"-1/5"],["B","ADD",41,36,"-1/20"],["B","ADD",40,36,"1/10"],["B","ADD",39,36,"-3/10"],["B","ADD",38,36,"-1/5"],["B","ADD",37,36,"-12/5"],["B","ADD",37,36,"7/3"],["B","ADD",38,36,"1/6"],["B","ADD",39,36,"1/6"],["B","ADD",40,36,"-1/12"],["B","ADD",41,36,"1/12"],["B","ADD",42,36,"1/6"],["B","ADD",43,36,"1/6"],["B","ADD",44,36,"-1/12"],["B","ADD",45,36,"1/12"],["B","ADD",46,36,"1/6"],["B","ADD",47,36,"1/6"],["B","ADD",49,36,"1/12"],["B","SCALE",36,"1/3"],["B","ADD",36,37,"-2"],["B","ADD",36,38,"-8"],["B","ADD",36,39,"20"],["B","ADD",36,40,"64"],["B","ADD",36,41,"40"],["B","ADD",36,42,"-8"],["B","ADD",36,43,"20"],["B","ADD",36,44,"64"],["B","ADD",36,45,"40"],["B","ADD",36,46,"-8"],["B","ADD",36,47,"20"],["B","ADD",36,48,"68"],["B","ADD",36,49,"28"],["B","IDLE_ONE",36,[6]],["B","ADD",36,49,"-28"],["B","ADD",36,48,"-68"],["B","ADD",36,47,"-20"],["B","ADD",36,46,"8"],["B","ADD",36,45,"-40"],["B","ADD",36,44,"-64"],["B","ADD",36,43,"-20"],["B","ADD",36,42,"8"],["B","ADD",36,41,"-40"],["B","ADD",36,40,"-64"],["B","ADD",36,39,"-20"],["B","ADD",36,38,"8"],["B","ADD",36,37,"2"],["B","SCALE",36,"3"],["B","ADD",49,36,"-1/12"],["B","ADD",47,36,"-1/6"],["B","ADD",46,36,"-1/6"],["B","ADD",45,36,"-1/12"],["B","ADD",44,36,"1/12"],["B","ADD",43,36,"-1/6"],["B","ADD",42,36,"-1/6"],["B","ADD",41,36,"-1/12"],["B","ADD",40,36,"1/12"],["B","ADD",39,36,"-1/6"],["B","ADD",38,36,"-1/6"],["B","ADD",37,36,"-7/3"],["B","ADD",37,36,"3"],["B","ADD",38,36,"1/2"],["B","ADD",39,36,"3/2"],["B","ADD",40,36,"-1/4"],["B","ADD",41,36,"-1/4"],["B","ADD",42,36,"1/2"],["B","ADD",43,36,"3/2"],["B","ADD",44,36,"-1/4"],["B","ADD",45,36,"-1/4"],["B","ADD",46,36,"1/2"],["B","ADD",47,36,"3/2"],["B","ADD",48,36,"-1/2"],["B","ADD",49,36,"1/2"],["B","SCALE",36,"-1"],["B","ADD",36,37,"1/2"],["B","ADD",36,39,"-1"],["B","ADD",36,40,"-4"],["B","ADD",36,41,"-2"],["B","ADD",36,43,"-1"],["B","ADD",36,44,"-4"],["B","ADD",36,45,"-2"],["B","ADD",36,47,"-1"],["B","ADD",36,48,"-4"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"-1/2"],["B","ADD",47,37,"-2"],["B","ADD",48,37,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,38,"1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-6"],["B","ADD",37,41,"-4"],["B","ADD",37,42,"1"],["B","ADD",37,43,"-2"],["B","ADD",37,44,"-6"],["B","ADD",37,45,"-4"],["B","ADD",37,46,"1"],["B","ADD",37,47,"-2"],["B","ADD",37,48,"-8"],["B","ADD",37,49,"-4"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",6,"-1"],["A","ADD",6,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-2"],["A","ADD",24,18,"-1"],["A","SCALE",24,"-1"],["A","LAMBDA",6,1],["A","LAMBDA",24,-1],["A","SCALE",24,"-1"],["J",6,[6,0,18,24],[36,37,"-1","1/2"]],["A","LAMBDA",6,-1],["A","LAMBDA",24,1],["A","SCALE",24,"-1"],["A","ADD",0,6,"-1"],["A","ADD",18,24,"-1"],["A","SCALE",24,"-1"],["A","ADD",24,18,"1"],["A","ADD",23,18,"2"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",6,0,"-1"],["A","SCALE",6,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,49,"4"],["B","ADD",37,48,"8"],["B","ADD",37,47,"2"],["B","ADD",37,46,"-1"],["B","ADD",37,45,"4"],["B","ADD",37,44,"6"],["B","ADD",37,43,"2"],["B","ADD",37,42,"-1"],["B","ADD",37,41,"4"],["B","ADD",37,40,"6"],["B","ADD",37,39,"2"],["B","ADD",37,38,"-1"],["B","SCALE",37,"2"],["B","ADD",48,37,"-1/2"],["B","ADD",47,37,"2"],["B","ADD",46,37,"1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,48,"4"],["B","ADD",36,47,"1"],["B","ADD",36,45,"2"],["B","ADD",36,44,"4"],["B","ADD",36,43,"1"],["B","ADD",36,41,"2"],["B","ADD",36,40,"4"],["B","ADD",36,39,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-1"],["B","ADD",49,36,"-1/2"],["B","ADD",48,36,"1/2"],["B","ADD",47,36,"-3/2"],["B","ADD",46,36,"-1/2"],["B","ADD",45,36,"1/4"],["B","ADD",44,36,"1/4"],["B","ADD",43,36,"-3/2"],["B","ADD",42,36,"-1/2"],["B","ADD",41,36,"1/4"],["B","ADD",40,36,"1/4"],["B","ADD",39,36,"-3/2"],["B","ADD",38,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"7"],["B","ADD",38,36,"5/2"],["B","ADD",39,36,"19/2"],["B","ADD",40,36,"-5/4"],["B","ADD",41,36,"-9/4"],["B","ADD",42,36,"5/2"],["B","ADD",43,36,"19/2"],["B","ADD",44,36,"-5/4"],["B","ADD",45,36,"-9/4"],["B","ADD",46,36,"5/2"],["B","ADD",47,36,"19/2"],["B","ADD",48,36,"-5/4"],["B","ADD",49,36,"-9/4"],["B","ADD",50,36,"-1/2"],["B","ADD",51,36,"3/2"],["B","SCALE",36,"-2"],["B","ADD",36,37,"7"],["B","ADD",36,38,"26"],["B","ADD",36,39,"-66"],["B","ADD",36,40,"-212"],["B","ADD",36,41,"-132"],["B","ADD",36,42,"26"],["B","ADD",36,43,"-66"],["B","ADD",36,44,"-212"],["B","ADD",36,45,"-132"],["B","ADD",36,46,"26"],["B","ADD",36,47,"-66"],["B","ADD",36,48,"-212"],["B","ADD",36,49,"-132"],["B","ADD",36,50,"14"],["B","ADD",36,51,"-26"],["B","IDLE_ONE",36,[7]],["B","ADD",36,51,"26"],["B","ADD",36,50,"-14"],["B","ADD",36,49,"132"],["B","ADD",36,48,"212"],["B","ADD",36,47,"66"],["B","ADD",36,46,"-26"],["B","ADD",36,45,"132"],["B","ADD",36,44,"212"],["B","ADD",36,43,"66"],["B","ADD",36,42,"-26"],["B","ADD",36,41,"132"],["B","ADD",36,40,"212"],["B","ADD",36,39,"66"],["B","ADD",36,38,"-26"],["B","ADD",36,37,"-7"],["B","SCALE",36,"-1/2"],["B","ADD",51,36,"-3/2"],["B","ADD",50,36,"1/2"],["B","ADD",49,36,"9/4"],["B","ADD",48,36,"5/4"],["B","ADD",47,36,"-19/2"],["B","ADD",46,36,"-5/2"],["B","ADD",45,36,"9/4"],["B","ADD",44,36,"5/4"],["B","ADD",43,36,"-19/2"],["B","ADD",42,36,"-5/2"],["B","ADD",41,36,"9/4"],["B","ADD",40,36,"5/4"],["B","ADD",39,36,"-19/2"],["B","ADD",38,36,"-5/2"],["B","ADD",37,36,"-7"],["B","ADD",37,36,"22/3"],["B","ADD",38,36,"8/3"],["B","ADD",39,36,"61/6"],["B","ADD",40,36,"-4/3"],["B","ADD",41,36,"-29/12"],["B","ADD",42,36,"8/3"],["B","ADD",43,36,"61/6"],["B","ADD",44,36,"-4/3"],["B","ADD",45,36,"-29/12"],["B","ADD",46,36,"8/3"],["B","ADD",47,36,"61/6"],["B","ADD",48,36,"-4/3"],["B","ADD",49,36,"-29/12"],["B","ADD",50,36,"-1/2"],["B","ADD",51,36,"5/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"2"],["B","ADD",36,38,"8"],["B","ADD",36,39,"-20"],["B","ADD",36,40,"-64"],["B","ADD",36,41,"-40"],["B","ADD",36,42,"8"],["B","ADD",36,43,"-20"],["B","ADD",36,44,"-64"],["B","ADD",36,45,"-40"],["B","ADD",36,46,"8"],["B","ADD",36,47,"-20"],["B","ADD",36,48,"-64"],["B","ADD",36,49,"-40"],["B","ADD",36,50,"4"],["B","ADD",36,51,"-8"],["B","IDLE_ONE",36,[7]],["B","ADD",36,51,"8"],["B","ADD",36,50,"-4"],["B","ADD",36,49,"40"],["B","ADD",36,48,"64"],["B","ADD",36,47,"20"],["B","ADD",36,46,"-8"],["B","ADD",36,45,"40"],["B","ADD",36,44,"64"],["B","ADD",36,43,"20"],["B","ADD",36,42,"-8"],["B","ADD",36,41,"40"],["B","ADD",36,40,"64"],["B","ADD",36,39,"20"],["B","ADD",36,38,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"3/2"],["B","ADD",51,36,"-5/3"],["B","ADD",50,36,"1/2"],["B","ADD",49,36,"29/12"],["B","ADD",48,36,"4/3"],["B","ADD",47,36,"-61/6"],["B","ADD",46,36,"-8/3"],["B","ADD",45,36,"29/12"],["B","ADD",44,36,"4/3"],["B","ADD",43,36,"-61/6"],["B","ADD",42,36,"-8/3"],["B","ADD",41,36,"29/12"],["B","ADD",40,36,"4/3"],["B","ADD",39,36,"-61/6"],["B","ADD",38,36,"-8/3"],["B","ADD",37,36,"-22/3"],["B","ADD",37,36,"1"],["B","ADD",38,36,"-1/2"],["B","ADD",39,36,"-5/2"],["B","ADD",40,36,"1/4"],["B","ADD",41,36,"3/4"],["B","ADD",42,36,"-1/2"],["B","ADD",43,36,"-5/2"],["B","ADD",44,36,"1/4"],["B","ADD",45,36,"3/4"],["B","ADD",46,36,"-1/2"],["B","ADD",47,36,"-5/2"],["B","ADD",48,36,"1/4"],["B","ADD",49,36,"3/4"],["B","ADD",50,36,"1/2"],["B","ADD",51,36,"1/2"],["B","ADD",36,38,"-1"],["B","ADD",36,39,"2"],["B","ADD",36,40,"6"],["B","ADD",36,41,"4"],["B","ADD",36,42,"-1"],["B","ADD",36,43,"2"],["B","ADD",36,44,"6"],["B","ADD",36,45,"4"],["B","ADD",36,46,"-1"],["B","ADD",36,47,"2"],["B","ADD",36,48,"6"],["B","ADD",36,49,"4"],["B","ADD",36,50,"-1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"-1/2"],["B","ADD",47,37,"-2"],["B","ADD",48,37,"1/4"],["B","ADD",49,37,"1/2"],["B","ADD",50,37,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,39,"-1"],["B","ADD",37,40,"-4"],["B","ADD",37,41,"-2"],["B","ADD",37,43,"-1"],["B","ADD",37,44,"-4"],["B","ADD",37,45,"-2"],["B","ADD",37,47,"-1"],["B","ADD",37,48,"-4"],["B","ADD",37,49,"-2"],["B","ADD",37,50,"2"],["B","ADD",37,51,"-1"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",7,"-1"],["A","ADD",7,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",6,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-2"],["A","ADD",24,18,"-2"],["A","ADD",25,18,"-1"],["A","SCALE",25,"-1"],["A","LAMBDA",7,1],["A","LAMBDA",25,-1],["A","SCALE",25,"-1"],["J",7,[7,0,18,25],[36,37,"-1","1/2"]],["A","LAMBDA",7,-1],["A","LAMBDA",25,1],["A","SCALE",25,"-1"],["A","ADD",0,7,"-1"],["A","ADD",18,25,"-1"],["A","SCALE",25,"-1"],["A","ADD",25,18,"1"],["A","ADD",24,18,"2"],["A","ADD",23,18,"2"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",6,0,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",7,0,"-1"],["A","SCALE",7,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,51,"1"],["B","ADD",37,50,"-2"],["B","ADD",37,49,"2"],["B","ADD",37,48,"4"],["B","ADD",37,47,"1"],["B","ADD",37,45,"2"],["B","ADD",37,44,"4"],["B","ADD",37,43,"1"],["B","ADD",37,41,"2"],["B","ADD",37,40,"4"],["B","ADD",37,39,"1"],["B","SCALE",37,"-2"],["B","ADD",50,37,"-1/2"],["B","ADD",49,37,"-1/2"],["B","ADD",48,37,"-1/4"],["B","ADD",47,37,"2"],["B","ADD",46,37,"1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,50,"1"],["B","ADD",36,49,"-4"],["B","ADD",36,48,"-6"],["B","ADD",36,47,"-2"],["B","ADD",36,46,"1"],["B","ADD",36,45,"-4"],["B","ADD",36,44,"-6"],["B","ADD",36,43,"-2"],["B","ADD",36,42,"1"],["B","ADD",36,41,"-4"],["B","ADD",36,40,"-6"],["B","ADD",36,39,"-2"],["B","ADD",36,38,"1"],["B","ADD",51,36,"-1/2"],["B","ADD",50,36,"-1/2"],["B","ADD",49,36,"-3/4"],["B","ADD",48,36,"-1/4"],["B","ADD",47,36,"5/2"],["B","ADD",46,36,"1/2"],["B","ADD",45,36,"-3/4"],["B","ADD",44,36,"-1/4"],["B","ADD",43,36,"5/2"],["B","ADD",42,36,"1/2"],["B","ADD",41,36,"-3/4"],["B","ADD",40,36,"-1/4"],["B","ADD",39,36,"5/2"],["B","ADD",38,36,"1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-11/60"],["B","ADD",45,36,"-7/60"],["B","ADD",46,36,"11/30"],["B","ADD",47,36,"29/30"],["B","ADD",48,36,"-11/60"],["B","ADD",49,36,"-7/60"],["B","ADD",50,36,"7/30"],["B","ADD",51,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-1748"],["B","ADD",36,45,"-1092"],["B","ADD",36,46,"218"],["B","ADD",36,47,"-546"],["B","ADD",36,48,"-1748"],["B","ADD",36,49,"-1092"],["B","ADD",36,50,"-982"],["B","ADD",36,51,"218"],["B","IDLE_ONE",36,[8]],["B","ADD",36,51,"-218"],["B","ADD",36,50,"982"],["B","ADD",36,49,"1092"],["B","ADD",36,48,"1748"],["B","ADD",36,47,"546"],["B","ADD",36,46,"-218"],["B","ADD",36,45,"1092"],["B","ADD",36,44,"1748"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"-15/2"],["B","ADD",51,36,"-11/30"],["B","ADD",50,36,"-7/30"],["B","ADD",49,36,"7/60"],["B","ADD",48,36,"11/60"],["B","ADD",47,36,"-29/30"],["B","ADD",46,36,"-11/30"],["B","ADD",45,36,"7/60"],["B","ADD",44,36,"11/60"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"1/2"],["B","ADD",45,38,"191/600"],["B","ADD",46,38,"-1"],["B","ADD",47,38,"-791/300"],["B","ADD",48,38,"1/2"],["B","ADD",49,38,"191/600"],["B","ADD",50,38,"-191/300"],["B","ADD",51,38,"-1"],["B","SCALE",38,"1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"64"],["B","ADD",38,45,"40"],["B","ADD",38,46,"-8"],["B","ADD",38,47,"20"],["B","ADD",38,48,"64"],["B","ADD",38,49,"40"],["B","ADD",38,50,"36"],["B","ADD",38,51,"-8"],["B","IDLE_ONE",38,[8]],["B","ADD",38,51,"8"],["B","ADD",38,50,"-36"],["B","ADD",38,49,"-40"],["B","ADD",38,48,"-64"],["B","ADD",38,47,"-20"],["B","ADD",38,46,"8"],["B","ADD",38,45,"-40"],["B","ADD",38,44,"-64"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"75"],["B","ADD",51,38,"1"],["B","ADD",50,38,"191/300"],["B","ADD",49,38,"-191/600"],["B","ADD",48,38,"-1/2"],["B","ADD",47,38,"791/300"],["B","ADD",46,38,"1"],["B","ADD",45,38,"-191/600"],["B","ADD",44,38,"-1/2"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","IDLE_ODD",68,[8],-1],["B","IDLE_ODD",69,[8],-1],["B","ADD",37,36,"11/5"],["B","ADD",38,36,"1/10"],["B","ADD",39,36,"-1/10"],["B","ADD",40,36,"-1/20"],["B","ADD",41,36,"3/20"],["B","ADD",42,36,"1/10"],["B","ADD",43,36,"-1/10"],["B","ADD",44,36,"-1/20"],["B","ADD",45,36,"3/20"],["B","ADD",46,36,"1/10"],["B","ADD",47,36,"-1/10"],["B","ADD",48,36,"-1/20"],["B","ADD",49,36,"3/20"],["B","ADD",50,36,"1/10"],["B","ADD",51,36,"-1/10"],["B","SCALE",36,"1/5"],["B","ADD",36,37,"-1/2"],["B","ADD",36,39,"1"],["B","ADD",36,40,"4"],["B","ADD",36,41,"2"],["B","ADD",36,43,"1"],["B","ADD",36,44,"4"],["B","ADD",36,45,"2"],["B","ADD",36,47,"1"],["B","ADD",36,48,"4"],["B","ADD",36,49,"2"],["B","ADD",36,51,"1"],["B","ADD",38,37,"-1/2"],["B","ADD",39,37,"-2"],["B","ADD",40,37,"1/4"],["B","ADD",41,37,"1/2"],["B","ADD",42,37,"-1/2"],["B","ADD",43,37,"-2"],["B","ADD",44,37,"1/4"],["B","ADD",45,37,"1/2"],["B","ADD",46,37,"-1/2"],["B","ADD",47,37,"-2"],["B","ADD",48,37,"1/4"],["B","ADD",49,37,"1/2"],["B","ADD",50,37,"-1/2"],["B","ADD",51,37,"-2"],["B","SCALE",37,"-5/2"],["B","ADD",37,38,"-1"],["B","ADD",37,39,"-2"],["B","ADD",37,40,"-10"],["B","ADD",37,41,"-4"],["B","ADD",37,42,"-1"],["B","ADD",37,43,"-2"],["B","ADD",37,44,"-10"],["B","ADD",37,45,"-4"],["B","ADD",37,46,"-1"],["B","ADD",37,47,"-2"],["B","ADD",37,48,"-10"],["B","ADD",37,49,"-4"],["B","ADD",37,50,"-1"],["B","ADD",37,51,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","SCALE",8,"-1"],["A","ADD",8,0,"1"],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",6,0,"-2"],["A","ADD",7,0,"-2"],["A","ADD",19,18,"-2"],["A","ADD",20,18,"-2"],["A","ADD",21,18,"-2"],["A","ADD",22,18,"-2"],["A","ADD",23,18,"-2"],["A","ADD",24,18,"-2"],["A","ADD",25,18,"-2"],["A","ADD",26,18,"-1"],["A","SCALE",26,"-1"],["A","LAMBDA",8,1],["A","LAMBDA",26,-1],["A","SCALE",26,"-1"],["J",8,[8,0,18,26],[36,37,"-1","1/2"]],["A","LAMBDA",8,-1],["A","LAMBDA",26,1],["A","SCALE",26,"-1"],["A","ADD",0,8,"-1"],["A","ADD",18,26,"-1"],["A","SCALE",26,"-1"],["A","ADD",26,18,"1"],["A","ADD",25,18,"2"],["A","ADD",24,18,"2"],["A","ADD",23,18,"2"],["A","ADD",22,18,"2"],["A","ADD",21,18,"2"],["A","ADD",20,18,"2"],["A","ADD",19,18,"2"],["A","ADD",7,0,"2"],["A","ADD",6,0,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","ADD",8,0,"-1"],["A","SCALE",8,"-1"],["A","ADD",1,0,"-2"],["A","IDLE_ONE",1,[2,3,4,5,6,7,8]],["A","ADD",1,0,"2"],["A","ADD",2,0,"-2"],["A","IDLE_ONE",2,[3,4,5,6,7,8]],["A","ADD",2,0,"2"],["A","ADD",3,0,"-2"],["A","IDLE_ONE",3,[4,5,6,7,8]],["A","ADD",3,0,"2"],["A","ADD",4,0,"-2"],["A","IDLE_ONE",4,[5,6,7,8]],["A","ADD",4,0,"2"],["A","ADD",5,0,"-2"],["A","IDLE_ONE",5,[6,7,8]],["A","ADD",5,0,"2"],["A","ADD",6,0,"-2"],["A","IDLE_ONE",6,[7,8]],["A","ADD",6,0,"2"],["A","ADD",7,0,"-2"],["A","IDLE_ONE",7,[8]],["A","ADD",7,0,"2"],["A","ADD",19,18,"-2"],["A","IDLE_ONE",19,[2,3,4,5,6,7,8]],["A","ADD",19,18,"2"],["A","ADD",20,18,"-2"],["A","IDLE_ONE",20,[3,4,5,6,7,8]],["A","ADD",20,18,"2"],["A","ADD",21,18,"-2"],["A","IDLE_ONE",21,[4,5,6,7,8]],["A","ADD",21,18,"2"],["A","ADD",22,18,"-2"],["A","IDLE_ONE",22,[5,6,7,8]],["A","ADD",22,18,"2"],["A","ADD",23,18,"-2"],["A","IDLE_ONE",23,[6,7,8]],["A","ADD",23,18,"2"],["A","ADD",24,18,"-2"],["A","IDLE_ONE",24,[7,8]],["A","ADD",24,18,"2"],["A","ADD",25,18,"-2"],["A","IDLE_ONE",25,[8]],["A","ADD",25,18,"2"],["A","SWAP",0,18],["A","ADD",19,0,"-2"],["A","ADD",20,0,"-2"],["A","ADD",21,0,"-2"],["A","ADD",22,0,"-2"],["A","ADD",23,0,"-2"],["A","ADD",24,0,"-2"],["A","ADD",25,0,"-2"],["A","ADD",26,0,"-2"],["A","SWAP",1,19],["A","ADD",1,20,"-1"],["A","ADD",1,21,"1"],["A","ADD",1,22,"-1"],["A","ADD",1,23,"1"],["A","ADD",1,24,"-1"],["A","ADD",1,25,"1"],["A","ADD",1,26,"-1"],["A","ADD",1,27,"-1"],["A","ADD",1,28,"1"],["A","ADD",1,29,"-1"],["A","ADD",1,30,"1"],["A","ADD",1,31,"-1"],["A","ADD",1,32,"1"],["A","ADD",1,33,"-1"],["A","ADD",1,34,"1"],["A","ADD",1,35,"-1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",1,35,"1"],["A","ADD",1,34,"-1"],["A","ADD",1,33,"1"],["A","ADD",1,32,"-1"],["A","ADD",1,31,"1"],["A","ADD",1,30,"-1"],["A","ADD",1,29,"1"],["A","ADD",1,28,"-1"],["A","ADD",1,27,"1"],["A","ADD",1,26,"1"],["A","ADD",1,25,"-1"],["A","ADD",1,24,"1"],["A","ADD",1,23,"-1"],["A","ADD",1,22,"1"],["A","ADD",1,21,"-1"],["A","ADD",1,20,"1"],["A","SWAP",1,19],["A","ADD",26,0,"2"],["A","ADD",25,0,"2"],["A","ADD",24,0,"2"],["A","ADD",23,0,"2"],["A","ADD",22,0,"2"],["A","ADD",21,0,"2"],["A","ADD",20,0,"2"],["A","ADD",19,0,"2"],["A","SWAP",0,18],["A","SWAP",0,19],["A","ADD",20,0,"-1"],["A","ADD",21,0,"-1"],["A","ADD",22,0,"-1"],["A","ADD",23,0,"-1"],["A","ADD",24,0,"-1"],["A","ADD",25,0,"-1"],["A","ADD",26,0,"-1"],["A","ADD",27,0,"-1"],["A","ADD",28,0,"-1"],["A","ADD",29,0,"-1"],["A","ADD",30,0,"-1"],["A","ADD",31,0,"-1"],["A","ADD",32,0,"-1"],["A","ADD",33,0,"-1"],["A","ADD",34,0,"-1"],["A","ADD",35,0,"-1"],["A","ADD",1,2,"-1"],["A","ADD",1,3,"1"],["A","ADD",1,4,"-1"],["A","ADD",1,5,"1"],["A","ADD",1,6,"-1"],["A","ADD",1,7,"1"],["A","ADD",1,8,"-1"],["A","ADD",1,9,"-1"],["A","ADD",1,10,"1"],["A","ADD",1,11,"-1"],["A","ADD",1,12,"1"],["A","ADD",1,13,"-1"],["A","ADD",1,14,"1"],["A","ADD",1,15,"-1"],["A","ADD",1,16,"1"],["A","ADD",1,17,"-1"],["A","ADD",1,18,"1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",1,18,"-1"],["A","ADD",1,17,"1"],["A","ADD",1,16,"-1"],["A","ADD",1,15,"1"],["A","ADD",1,14,"-1"],["A","ADD",1,13,"1"],["A","ADD",1,12,"-1"],["A","ADD",1,11,"1"],["A","ADD",1,10,"-1"],["A","ADD",1,9,"1"],["A","ADD",1,8,"1"],["A","ADD",1,7,"-1"],["A","ADD",1,6,"1"],["A","ADD",1,5,"-1"],["A","ADD",1,4,"1"],["A","ADD",1,3,"-1"],["A","ADD",1,2,"1"],["A","ADD",35,0,"1"],["A","ADD",34,0,"1"],["A","ADD",33,0,"1"],["A","ADD",32,0,"1"],["A","ADD",31,0,"1"],["A","ADD",30,0,"1"],["A","ADD",29,0,"1"],["A","ADD",28,0,"1"],["A","ADD",27,0,"1"],["A","ADD",26,0,"1"],["A","ADD",25,0,"1"],["A","ADD",24,0,"1"],["A","ADD",23,0,"1"],["A","ADD",22,0,"1"],["A","ADD",21,0,"1"],["A","ADD",20,0,"1"],["A","SWAP",0,19],["A","ADD",1,0,"-2"],["A","ADD",2,0,"-2"],["A","ADD",3,0,"-2"],["A","ADD",4,0,"-2"],["A","ADD",5,0,"-2"],["A","ADD",6,0,"-2"],["A","ADD",7,0,"-2"],["A","ADD",8,0,"-2"],["A","ADD",19,0,"1"],["A","ADD",20,0,"1"],["A","ADD",21,0,"1"],["A","ADD",22,0,"1"],["A","ADD",23,0,"1"],["A","ADD",24,0,"1"],["A","ADD",25,0,"1"],["A","ADD",26,0,"1"],["A","ADD",27,0,"1"],["A","ADD",28,0,"1"],["A","ADD",29,0,"1"],["A","ADD",30,0,"1"],["A","ADD",31,0,"1"],["A","ADD",32,0,"1"],["A","ADD",33,0,"1"],["A","ADD",34,0,"1"],["A","ADD",35,0,"1"],["A","ADD",1,2,"-1"],["A","ADD",1,3,"1"],["A","ADD",1,4,"-1"],["A","ADD",1,5,"1"],["A","ADD",1,6,"-1"],["A","ADD",1,7,"1"],["A","ADD",1,8,"-1"],["A","ADD",1,9,"-1"],["A","ADD",1,10,"1"],["A","ADD",1,11,"-1"],["A","ADD",1,12,"1"],["A","ADD",1,13,"-1"],["A","ADD",1,14,"1"],["A","ADD",1,15,"-1"],["A","ADD",1,16,"1"],["A","ADD",1,17,"-1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",1,17,"1"],["A","ADD",1,16,"-1"],["A","ADD",1,15,"1"],["A","ADD",1,14,"-1"],["A","ADD",1,13,"1"],["A","ADD",1,12,"-1"],["A","ADD",1,11,"1"],["A","ADD",1,10,"-1"],["A","ADD",1,9,"1"],["A","ADD",1,8,"1"],["A","ADD",1,7,"-1"],["A","ADD",1,6,"1"],["A","ADD",1,5,"-1"],["A","ADD",1,4,"1"],["A","ADD",1,3,"-1"],["A","ADD",1,2,"1"],["A","ADD",35,0,"-1"],["A","ADD",34,0,"-1"],["A","ADD",33,0,"-1"],["A","ADD",32,0,"-1"],["A","ADD",31,0,"-1"],["A","ADD",30,0,"-1"],["A","ADD",29,0,"-1"],["A","ADD",28,0,"-1"],["A","ADD",27,0,"-1"],["A","ADD",26,0,"-1"],["A","ADD",25,0,"-1"],["A","ADD",24,0,"-1"],["A","ADD",23,0,"-1"],["A","ADD",22,0,"-1"],["A","ADD",21,0,"-1"],["A","ADD",20,0,"-1"],["A","ADD",19,0,"-1"],["A","ADD",8,0,"2"],["A","ADD",7,0,"2"],["A","ADD",6,0,"2"],["A","ADD",5,0,"2"],["A","ADD",4,0,"2"],["A","ADD",3,0,"2"],["A","ADD",2,0,"2"],["A","ADD",1,0,"2"],["A","SWAP",0,1],["A","ADD",2,0,"-1"],["A","ADD",3,0,"-1"],["A","ADD",4,0,"-1"],["A","ADD",5,0,"-1"],["A","ADD",6,0,"-1"],["A","ADD",7,0,"-1"],["A","ADD",8,0,"-1"],["A","ADD",9,0,"-1"],["A","ADD",10,0,"-1"],["A","ADD",11,0,"-1"],["A","ADD",12,0,"-1"],["A","ADD",13,0,"-1"],["A","ADD",14,0,"-1"],["A","ADD",15,0,"-1"],["A","ADD",16,0,"-1"],["A","ADD",17,0,"-1"],["A","LAMBDA",1,1],["A","QUERY",0,1,-1],["A","LAMBDA",1,-1],["A","ADD",0,1,"-1"],["A","ADD",17,0,"1"],["A","ADD",16,0,"1"],["A","ADD",15,0,"1"],["A","ADD",14,0,"1"],["A","ADD",13,0,"1"],["A","ADD",12,0,"1"],["A","ADD",11,0,"1"],["A","ADD",10,0,"1"],["A","ADD",9,0,"1"],["A","ADD",8,0,"1"],["A","ADD",7,0,"1"],["A","ADD",6,0,"1"],["A","ADD",5,0,"1"],["A","ADD",4,0,"1"],["A","ADD",3,0,"1"],["A","ADD",2,0,"1"],["A","SWAP",0,1],["A","ADD",10,0,"2"],["A","IDLE_ONE",10,[9]],["A","ADD",10,0,"-2"],["A","ADD",11,0,"2"],["A","IDLE_ONE",11,[9,10]],["A","ADD",11,0,"-2"],["A","ADD",12,0,"2"],["A","IDLE_ONE",12,[9,10,11]],["A","ADD",12,0,"-2"],["A","ADD",13,0,"2"],["A","IDLE_ONE",13,[9,10,11,12]],["A","ADD",13,0,"-2"],["A","ADD",14,0,"2"],["A","IDLE_ONE",14,[9,10,11,12,13]],["A","ADD",14,0,"-2"],["A","ADD",15,0,"2"],["A","IDLE_ONE",15,[9,10,11,12,13,14]],["A","ADD",15,0,"-2"],["A","ADD",16,0,"2"],["A","IDLE_ONE",16,[9,10,11,12,13,14,15]],["A","ADD",16,0,"-2"],["A","ADD",17,0,"2"],["A","IDLE_ONE",17,[9,10,11,12,13,14,15,16]],["A","ADD",17,0,"-2"],["A","ADD",28,18,"2"],["A","IDLE_ONE",28,[9]],["A","ADD",28,18,"-2"],["A","ADD",29,18,"2"],["A","IDLE_ONE",29,[9,10]],["A","ADD",29,18,"-2"],["A","ADD",30,18,"2"],["A","IDLE_ONE",30,[9,10,11]],["A","ADD",30,18,"-2"],["A","ADD",31,18,"2"],["A","IDLE_ONE",31,[9,10,11,12]],["A","ADD",31,18,"-2"],["A","ADD",32,18,"2"],["A","IDLE_ONE",32,[9,10,11,12,13]],["A","ADD",32,18,"-2"],["A","ADD",33,18,"2"],["A","IDLE_ONE",33,[9,10,11,12,13,14]],["A","ADD",33,18,"-2"],["A","ADD",34,18,"2"],["A","IDLE_ONE",34,[9,10,11,12,13,14,15]],["A","ADD",34,18,"-2"],["A","ADD",35,18,"2"],["A","IDLE_ONE",35,[9,10,11,12,13,14,15,16]],["A","ADD",35,18,"-2"],["B","LAMBDA",36,-1],["B","ADD",37,36,"1"],["B","SCALE",37,"-2"],["B","ADD",37,51,"2"],["B","ADD",37,50,"1"],["B","ADD",37,49,"4"],["B","ADD",37,48,"10"],["B","ADD",37,47,"2"],["B","ADD",37,46,"1"],["B","ADD",37,45,"4"],["B","ADD",37,44,"10"],["B","ADD",37,43,"2"],["B","ADD",37,42,"1"],["B","ADD",37,41,"4"],["B","ADD",37,40,"10"],["B","ADD",37,39,"2"],["B","ADD",37,38,"1"],["B","SCALE",37,"-2/5"],["B","ADD",51,37,"2"],["B","ADD",50,37,"1/2"],["B","ADD",49,37,"-1/2"],["B","ADD",48,37,"-1/4"],["B","ADD",47,37,"2"],["B","ADD",46,37,"1/2"],["B","ADD",45,37,"-1/2"],["B","ADD",44,37,"-1/4"],["B","ADD",43,37,"2"],["B","ADD",42,37,"1/2"],["B","ADD",41,37,"-1/2"],["B","ADD",40,37,"-1/4"],["B","ADD",39,37,"2"],["B","ADD",38,37,"1/2"],["B","ADD",36,51,"-1"],["B","ADD",36,49,"-2"],["B","ADD",36,48,"-4"],["B","ADD",36,47,"-1"],["B","ADD",36,45,"-2"],["B","ADD",36,44,"-4"],["B","ADD",36,43,"-1"],["B","ADD",36,41,"-2"],["B","ADD",36,40,"-4"],["B","ADD",36,39,"-1"],["B","ADD",36,37,"1/2"],["B","SCALE",36,"5"],["B","ADD",51,36,"1/10"],["B","ADD",50,36,"-1/10"],["B","ADD",49,36,"-3/20"],["B","ADD",48,36,"1/20"],["B","ADD",47,36,"1/10"],["B","ADD",46,36,"-1/10"],["B","ADD",45,36,"-3/20"],["B","ADD",44,36,"1/20"],["B","ADD",43,36,"1/10"],["B","ADD",42,36,"-1/10"],["B","ADD",41,36,"-3/20"],["B","ADD",40,36,"1/20"],["B","ADD",39,36,"1/10"],["B","ADD",38,36,"-1/10"],["B","ADD",37,36,"-11/5"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"7/30"],["B","ADD",39,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"-3"],["B","ADD",36,38,"62"],["B","ADD",36,39,"-14"],["B","IDLE_ONE",36,[2,3,4,5,6,7,8]],["B","ADD",36,39,"14"],["B","ADD",36,38,"-62"],["B","ADD",36,37,"3"],["B","SCALE",36,"-15/2"],["B","ADD",39,36,"-11/30"],["B","ADD",38,36,"-7/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"13/3"],["B","ADD",37,38,"-71/6"],["B","ADD",39,38,"-19/12"],["B","SCALE",38,"1/3"],["B","ADD",38,37,"2"],["B","ADD",38,39,"8"],["B","IDLE_ONE",38,[2,3,4,5,6,7,8]],["B","ADD",38,39,"-8"],["B","ADD",38,37,"-2"],["B","SCALE",38,"3"],["B","ADD",39,38,"19/12"],["B","ADD",37,38,"71/6"],["B","ADD",36,38,"-13/3"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-1/15"],["B","ADD",41,36,"-1/6"],["B","SCALE",36,"2/15"],["B","ADD",36,37,"6"],["B","ADD",36,38,"22"],["B","ADD",36,39,"-56"],["B","ADD",36,40,"-68"],["B","ADD",36,41,"-156"],["B","IDLE_ONE",36,[3,4,5,6,7,8]],["B","ADD",36,41,"156"],["B","ADD",36,40,"68"],["B","ADD",36,39,"56"],["B","ADD",36,38,"-22"],["B","ADD",36,37,"-6"],["B","SCALE",36,"15/2"],["B","ADD",41,36,"1/6"],["B","ADD",40,36,"1/15"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-2"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","SWAP",36,37],["B","ADD",36,37,"-3"],["B","SWAP",36,37],["B","ADD",36,37,"-2"],["B","SWAP",36,37],["B","ADD",36,37,"-2"],["B","SWAP",36,37],["B","SWAP",36,38],["B","ADD",36,38,"-30"],["B","SWAP",36,38],["B","ADD",36,38,"-2"],["B","SWAP",36,38],["B","SWAP",36,39],["B","ADD",36,39,"-161"],["B","SWAP",36,39],["B","ADD",36,40,"1"],["B","SWAP",36,40],["B","ADD",36,40,"-1"],["B","SWAP",36,40],["B","ADD",36,40,"-10"],["B","SWAP",36,40],["B","SWAP",36,41],["B","ADD",36,41,"-28"],["B","SWAP",36,41],["B","SCALE",36,"4"],["B","ADD",36,37,"-93"],["B","ADD",36,38,"-347"],["B","ADD",36,39,"10"],["B","ADD",36,40,"12"],["B","ADD",36,41,"28"],["B","IDLE_ONE",36,[3,4,5,6,7,8]],["B","ADD",36,41,"-28"],["B","ADD",36,40,"-12"],["B","ADD",36,39,"-10"],["B","ADD",36,38,"347"],["B","ADD",36,37,"93"],["B","SCALE",36,"1/4"],["B","SWAP",36,41],["B","ADD",36,41,"28"],["B","SWAP",36,41],["B","SWAP",36,40],["B","ADD",36,40,"10"],["B","SWAP",36,40],["B","ADD",36,40,"1"],["B","SWAP",36,40],["B","ADD",36,40,"-1"],["B","SWAP",36,39],["B","ADD",36,39,"161"],["B","SWAP",36,39],["B","SWAP",36,38],["B","ADD",36,38,"2"],["B","SWAP",36,38],["B","ADD",36,38,"30"],["B","SWAP",36,38],["B","SWAP",36,37],["B","ADD",36,37,"2"],["B","SWAP",36,37],["B","ADD",36,37,"2"],["B","SWAP",36,37],["B","ADD",36,37,"3"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"2"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"1"],["B","SWAP",36,37],["B","ADD",36,37,"-1"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"7/30"],["B","ADD",43,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"-982"],["B","ADD",36,43,"218"],["B","IDLE_ONE",36,[4,5,6,7,8]],["B","ADD",36,43,"-218"],["B","ADD",36,42,"982"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"-15/2"],["B","ADD",43,36,"-11/30"],["B","ADD",42,36,"-7/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-191/300"],["B","ADD",43,38,"-1"],["B","SCALE",38,"1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"36"],["B","ADD",38,43,"-8"],["B","IDLE_ONE",38,[4,5,6,7,8]],["B","ADD",38,43,"8"],["B","ADD",38,42,"-36"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"75"],["B","ADD",43,38,"1"],["B","ADD",42,38,"191/300"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-1/15"],["B","ADD",45,36,"-1/6"],["B","SCALE",36,"2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-656"],["B","ADD",36,45,"-1528"],["B","IDLE_ONE",36,[5,6,7,8]],["B","ADD",36,45,"1528"],["B","ADD",36,44,"656"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"15/2"],["B","ADD",45,36,"1/6"],["B","ADD",44,36,"1/15"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"109/600"],["B","ADD",45,38,"91/200"],["B","SCALE",38,"-1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"24"],["B","ADD",38,45,"56"],["B","IDLE_ONE",38,[5,6,7,8]],["B","ADD",38,45,"-56"],["B","ADD",38,44,"-24"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"-75"],["B","ADD",45,38,"-91/200"],["B","ADD",44,38,"-109/600"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-11/60"],["B","ADD",45,36,"-7/60"],["B","ADD",46,36,"7/30"],["B","ADD",47,36,"11/30"],["B","SCALE",36,"-2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-1748"],["B","ADD",36,45,"-1092"],["B","ADD",36,46,"-982"],["B","ADD",36,47,"218"],["B","IDLE_ONE",36,[6,7,8]],["B","ADD",36,47,"-218"],["B","ADD",36,46,"982"],["B","ADD",36,45,"1092"],["B","ADD",36,44,"1748"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"-15/2"],["B","ADD",47,36,"-11/30"],["B","ADD",46,36,"-7/30"],["B","ADD",45,36,"7/60"],["B","ADD",44,36,"11/60"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"1/2"],["B","ADD",45,38,"191/600"],["B","ADD",46,38,"-191/300"],["B","ADD",47,38,"-1"],["B","SCALE",38,"1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"64"],["B","ADD",38,45,"40"],["B","ADD",38,46,"36"],["B","ADD",38,47,"-8"],["B","IDLE_ONE",38,[6,7,8]],["B","ADD",38,47,"8"],["B","ADD",38,46,"-36"],["B","ADD",38,45,"-40"],["B","ADD",38,44,"-64"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"75"],["B","ADD",47,38,"1"],["B","ADD",46,38,"191/300"],["B","ADD",45,38,"-191/600"],["B","ADD",44,38,"-1/2"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/15"],["B","ADD",38,36,"11/30"],["B","ADD",39,36,"29/30"],["B","ADD",40,36,"-11/60"],["B","ADD",41,36,"-7/60"],["B","ADD",42,36,"11/30"],["B","ADD",43,36,"29/30"],["B","ADD",44,36,"-11/60"],["B","ADD",45,36,"-7/60"],["B","ADD",46,36,"11/30"],["B","ADD",47,36,"29/30"],["B","ADD",48,36,"-1/15"],["B","ADD",49,36,"-1/6"],["B","SCALE",36,"2/15"],["B","ADD",36,37,"55"],["B","ADD",36,38,"218"],["B","ADD",36,39,"-546"],["B","ADD",36,40,"-1748"],["B","ADD",36,41,"-1092"],["B","ADD",36,42,"218"],["B","ADD",36,43,"-546"],["B","ADD",36,44,"-1748"],["B","ADD",36,45,"-1092"],["B","ADD",36,46,"218"],["B","ADD",36,47,"-546"],["B","ADD",36,48,"-656"],["B","ADD",36,49,"-1528"],["B","IDLE_ONE",36,[7,8]],["B","ADD",36,49,"1528"],["B","ADD",36,48,"656"],["B","ADD",36,47,"546"],["B","ADD",36,46,"-218"],["B","ADD",36,45,"1092"],["B","ADD",36,44,"1748"],["B","ADD",36,43,"546"],["B","ADD",36,42,"-218"],["B","ADD",36,41,"1092"],["B","ADD",36,40,"1748"],["B","ADD",36,39,"546"],["B","ADD",36,38,"-218"],["B","ADD",36,37,"-55"],["B","SCALE",36,"15/2"],["B","ADD",49,36,"1/6"],["B","ADD",48,36,"1/15"],["B","ADD",47,36,"-29/30"],["B","ADD",46,36,"-11/30"],["B","ADD",45,36,"7/60"],["B","ADD",44,36,"11/60"],["B","ADD",43,36,"-29/30"],["B","ADD",42,36,"-11/30"],["B","ADD",41,36,"7/60"],["B","ADD",40,36,"11/60"],["B","ADD",39,36,"-29/30"],["B","ADD",38,36,"-11/30"],["B","ADD",37,36,"-41/15"],["B","ADD",36,38,"409/150"],["B","ADD",37,38,"-559/75"],["B","ADD",39,38,"-791/300"],["B","ADD",40,38,"1/2"],["B","ADD",41,38,"191/600"],["B","ADD",42,38,"-1"],["B","ADD",43,38,"-791/300"],["B","ADD",44,38,"1/2"],["B","ADD",45,38,"191/600"],["B","ADD",46,38,"-1"],["B","ADD",47,38,"-791/300"],["B","ADD",48,38,"109/600"],["B","ADD",49,38,"91/200"],["B","SCALE",38,"-1/75"],["B","ADD",38,37,"-2"],["B","ADD",38,39,"20"],["B","ADD",38,40,"64"],["B","ADD",38,41,"40"],["B","ADD",38,42,"-8"],["B","ADD",38,43,"20"],["B","ADD",38,44,"64"],["B","ADD",38,45,"40"],["B","ADD",38,46,"-8"],["B","ADD",38,47,"20"],["B","ADD",38,48,"24"],["B","ADD",38,49,"56"],["B","IDLE_ONE",38,[7,8]],["B","ADD",38,49,"-56"],["B","ADD",38,48,"-24"],["B","ADD",38,47,"-20"],["B","ADD",38,46,"8"],["B","ADD",38,45,"-40"],["B","ADD",38,44,"-64"],["B","ADD",38,43,"-20"],["B","ADD",38,42,"8"],["B","ADD",38,41,"-40"],["B","ADD",38,40,"-64"],["B","ADD",38,39,"-20"],["B","ADD",38,37,"2"],["B","SCALE",38,"-75"],["B","ADD",49,38,"-91/200"],["B","ADD",48,38,"-109/600"],["B","ADD",47,38,"791/300"],["B","ADD",46,38,"1"],["B","ADD",45,38,"-191/600"],["B","ADD",44,38,"-1/2"],["B","ADD",43,38,"791/300"],["B","ADD",42,38,"1"],["B","ADD",41,38,"-191/600"],["B","ADD",40,38,"-1/2"],["B","ADD",39,38,"791/300"],["B","ADD",37,38,"559/75"],["B","ADD",36,38,"-409/150"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"1/16"],["B","ADD",53,36,"9/32"],["B","SCALE",36,"-1/16"],["B","ADD",36,52,"-10"],["B","ADD",36,53,"6"],["B","IDLE_ONE",36,[16,15,14,13,12,11,10,9]],["B","ADD",36,53,"-6"],["B","ADD",36,52,"10"],["B","SCALE",36,"-16"],["B","ADD",53,36,"-9/32"],["B","ADD",52,36,"-1/16"],["B","ADD",37,36,"-41/16"],["B","ADD",36,37,"7/18"],["B","ADD",52,37,"-1/36"],["B","ADD",53,37,"-1/9"],["B","SCALE",37,"-1/18"],["B","ADD",37,52,"-22"],["B","ADD",37,53,"14"],["B","IDLE_ONE",37,[16,15,14,13,12,11,10,9]],["B","ADD",37,53,"-14"],["B","ADD",37,52,"22"],["B","SCALE",37,"-18"],["B","ADD",53,37,"1/9"],["B","ADD",52,37,"1/36"],["B","ADD",36,37,"-7/18"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"1/32"],["B","ADD",55,36,"5/64"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"5"],["B","ADD",36,52,"22"],["B","ADD",36,53,"-54"],["B","ADD",36,54,"32"],["B","ADD",36,55,"76"],["B","IDLE_ONE",36,[15,14,13,12,11,10,9]],["B","ADD",36,55,"-76"],["B","ADD",36,54,"-32"],["B","ADD",36,53,"54"],["B","ADD",36,52,"-22"],["B","ADD",36,37,"-5"],["B","SCALE",36,"-16"],["B","ADD",55,36,"-5/64"],["B","ADD",54,36,"-1/32"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-11/60"],["B","ADD",55,52,"-9/20"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"-1"],["B","ADD",52,53,"10"],["B","ADD",52,54,"-6"],["B","ADD",52,55,"-14"],["B","IDLE_ONE",52,[15,14,13,12,11,10,9]],["B","ADD",52,55,"14"],["B","ADD",52,54,"6"],["B","ADD",52,53,"-10"],["B","ADD",52,37,"1"],["B","SCALE",52,"15"],["B","ADD",55,52,"9/20"],["B","ADD",54,52,"11/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"1/16"],["B","ADD",57,36,"9/32"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"-5"],["B","ADD",36,52,"-22"],["B","ADD",36,53,"54"],["B","ADD",36,54,"-140"],["B","ADD",36,55,"-32"],["B","ADD",36,56,"-120"],["B","ADD",36,57,"76"],["B","IDLE_ONE",36,[14,13,12,11,10,9]],["B","ADD",36,57,"-76"],["B","ADD",36,56,"120"],["B","ADD",36,55,"32"],["B","ADD",36,54,"140"],["B","ADD",36,53,"-54"],["B","ADD",36,52,"22"],["B","ADD",36,37,"5"],["B","SCALE",36,"-16"],["B","ADD",57,36,"-9/32"],["B","ADD",56,36,"-1/16"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-11/30"],["B","ADD",57,52,"-49/30"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-10"],["B","ADD",52,54,"26"],["B","ADD",52,55,"6"],["B","ADD",52,56,"22"],["B","ADD",52,57,"-14"],["B","IDLE_ONE",52,[14,13,12,11,10,9]],["B","ADD",52,57,"14"],["B","ADD",52,56,"-22"],["B","ADD",52,55,"-6"],["B","ADD",52,54,"-26"],["B","ADD",52,53,"10"],["B","ADD",52,37,"-1"],["B","SCALE",52,"15"],["B","ADD",57,52,"49/30"],["B","ADD",56,52,"11/30"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"11/64"],["B","ADD",57,36,"29/64"],["B","ADD",58,36,"1/32"],["B","ADD",59,36,"5/64"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"5"],["B","ADD",36,52,"22"],["B","ADD",36,53,"-54"],["B","ADD",36,54,"140"],["B","ADD",36,55,"32"],["B","ADD",36,56,"22"],["B","ADD",36,57,"-54"],["B","ADD",36,58,"32"],["B","ADD",36,59,"76"],["B","IDLE_ONE",36,[13,12,11,10,9]],["B","ADD",36,59,"-76"],["B","ADD",36,58,"-32"],["B","ADD",36,57,"54"],["B","ADD",36,56,"-22"],["B","ADD",36,55,"-32"],["B","ADD",36,54,"-140"],["B","ADD",36,53,"54"],["B","ADD",36,52,"-22"],["B","ADD",36,37,"-5"],["B","SCALE",36,"-16"],["B","ADD",59,36,"-5/64"],["B","ADD",58,36,"-1/32"],["B","ADD",57,36,"-29/64"],["B","ADD",56,36,"-11/64"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-79/30"],["B","ADD",58,52,"-11/60"],["B","ADD",59,52,"-9/20"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"-1"],["B","ADD",52,53,"10"],["B","ADD",52,54,"-26"],["B","ADD",52,55,"-6"],["B","ADD",52,56,"-4"],["B","ADD",52,57,"10"],["B","ADD",52,58,"-6"],["B","ADD",52,59,"-14"],["B","IDLE_ONE",52,[13,12,11,10,9]],["B","ADD",52,59,"14"],["B","ADD",52,58,"6"],["B","ADD",52,57,"-10"],["B","ADD",52,56,"4"],["B","ADD",52,55,"6"],["B","ADD",52,54,"26"],["B","ADD",52,53,"-10"],["B","ADD",52,37,"1"],["B","SCALE",52,"15"],["B","ADD",59,52,"9/20"],["B","ADD",58,52,"11/60"],["B","ADD",57,52,"79/30"],["B","ADD",56,52,"1"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"11/64"],["B","ADD",57,36,"29/64"],["B","ADD",58,36,"9/64"],["B","ADD",59,36,"1/32"],["B","ADD",60,36,"1/16"],["B","ADD",61,36,"9/32"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"-5"],["B","ADD",36,52,"-22"],["B","ADD",36,53,"54"],["B","ADD",36,54,"-140"],["B","ADD",36,55,"-32"],["B","ADD",36,56,"-22"],["B","ADD",36,57,"54"],["B","ADD",36,58,"-140"],["B","ADD",36,59,"-32"],["B","ADD",36,60,"-120"],["B","ADD",36,61,"76"],["B","IDLE_ONE",36,[12,11,10,9]],["B","ADD",36,61,"-76"],["B","ADD",36,60,"120"],["B","ADD",36,59,"32"],["B","ADD",36,58,"140"],["B","ADD",36,57,"-54"],["B","ADD",36,56,"22"],["B","ADD",36,55,"32"],["B","ADD",36,54,"140"],["B","ADD",36,53,"-54"],["B","ADD",36,52,"22"],["B","ADD",36,37,"5"],["B","SCALE",36,"-16"],["B","ADD",61,36,"-9/32"],["B","ADD",60,36,"-1/16"],["B","ADD",59,36,"-1/32"],["B","ADD",58,36,"-9/64"],["B","ADD",57,36,"-29/64"],["B","ADD",56,36,"-11/64"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-79/30"],["B","ADD",58,52,"-49/60"],["B","ADD",59,52,"-11/60"],["B","ADD",60,52,"-11/30"],["B","ADD",61,52,"-49/30"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-10"],["B","ADD",52,54,"26"],["B","ADD",52,55,"6"],["B","ADD",52,56,"4"],["B","ADD",52,57,"-10"],["B","ADD",52,58,"26"],["B","ADD",52,59,"6"],["B","ADD",52,60,"22"],["B","ADD",52,61,"-14"],["B","IDLE_ONE",52,[12,11,10,9]],["B","ADD",52,61,"14"],["B","ADD",52,60,"-22"],["B","ADD",52,59,"-6"],["B","ADD",52,58,"-26"],["B","ADD",52,57,"10"],["B","ADD",52,56,"-4"],["B","ADD",52,55,"-6"],["B","ADD",52,54,"-26"],["B","ADD",52,53,"10"],["B","ADD",52,37,"-1"],["B","SCALE",52,"15"],["B","ADD",61,52,"49/30"],["B","ADD",60,52,"11/30"],["B","ADD",59,52,"11/60"],["B","ADD",58,52,"49/60"],["B","ADD",57,52,"79/30"],["B","ADD",56,52,"1"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"41/16"],["B","ADD",52,36,"11/64"],["B","ADD",53,36,"29/64"],["B","ADD",54,36,"9/64"],["B","ADD",55,36,"1/32"],["B","ADD",56,36,"11/64"],["B","ADD",57,36,"29/64"],["B","ADD",58,36,"9/64"],["B","ADD",59,36,"1/32"],["B","ADD",60,36,"11/64"],["B","ADD",61,36,"29/64"],["B","ADD",62,36,"1/32"],["B","ADD",63,36,"5/64"],["B","SCALE",36,"-1/16"],["B","ADD",36,37,"5"],["B","ADD",36,52,"22"],["B","ADD",36,53,"-54"],["B","ADD",36,54,"140"],["B","ADD",36,55,"32"],["B","ADD",36,56,"22"],["B","ADD",36,57,"-54"],["B","ADD",36,58,"140"],["B","ADD",36,59,"32"],["B","ADD",36,60,"22"],["B","ADD",36,61,"-54"],["B","ADD",36,62,"32"],["B","ADD",36,63,"76"],["B","IDLE_ONE",36,[11,10,9]],["B","ADD",36,63,"-76"],["B","ADD",36,62,"-32"],["B","ADD",36,61,"54"],["B","ADD",36,60,"-22"],["B","ADD",36,59,"-32"],["B","ADD",36,58,"-140"],["B","ADD",36,57,"54"],["B","ADD",36,56,"-22"],["B","ADD",36,55,"-32"],["B","ADD",36,54,"-140"],["B","ADD",36,53,"54"],["B","ADD",36,52,"-22"],["B","ADD",36,37,"-5"],["B","SCALE",36,"-16"],["B","ADD",63,36,"-5/64"],["B","ADD",62,36,"-1/32"],["B","ADD",61,36,"-29/64"],["B","ADD",60,36,"-11/64"],["B","ADD",59,36,"-1/32"],["B","ADD",58,36,"-9/64"],["B","ADD",57,36,"-29/64"],["B","ADD",56,36,"-11/64"],["B","ADD",55,36,"-1/32"],["B","ADD",54,36,"-9/64"],["B","ADD",53,36,"-29/64"],["B","ADD",52,36,"-11/64"],["B","ADD",37,36,"-41/16"],["B","ADD",36,52,"29/5"],["B","ADD",37,52,"-223/15"],["B","ADD",53,52,"-79/30"],["B","ADD",54,52,"-49/60"],["B","ADD",55,52,"-11/60"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-79/30"],["B","ADD",58,52,"-49/60"],["B","ADD",59,52,"-11/60"],["B","ADD",60,52,"-1"],["B","ADD",61,52,"-79/30"],["B","ADD",62,52,"-11/60"],["B","ADD",63,52,"-9/20"],["B","SCALE",52,"1/15"],["B","ADD",52,37,"-1"],["B","ADD",52,53,"10"],["B","ADD",52,54,"-26"],["B","ADD",52,55,"-6"],["B","ADD",52,56,"-4"],["B","ADD",52,57,"10"],["B","ADD",52,58,"-26"],["B","ADD",52,59,"-6"],["B","ADD",52,60,"-4"],["B","ADD",52,61,"10"],["B","ADD",52,62,"-6"],["B","ADD",52,63,"-14"],["B","IDLE_ONE",52,[11,10,9]],["B","ADD",52,63,"14"],["B","ADD",52,62,"6"],["B","ADD",52,61,"-10"],["B","ADD",52,60,"4"],["B","ADD",52,59,"6"],["B","ADD",52,58,"26"],["B","ADD",52,57,"-10"],["B","ADD",52,56,"4"],["B","ADD",52,55,"6"],["B","ADD",52,54,"26"],["B","ADD",52,53,"-10"],["B","ADD",52,37,"1"],["B","SCALE",52,"15"],["B","ADD",63,52,"9/20"],["B","ADD",62,52,"11/60"],["B","ADD",61,52,"79/30"],["B","ADD",60,52,"1"],["B","ADD",59,52,"11/60"],["B","ADD",58,52,"49/60"],["B","ADD",57,52,"79/30"],["B","ADD",56,52,"1"],["B","ADD",55,52,"11/60"],["B","ADD",54,52,"49/60"],["B","ADD",53,52,"79/30"],["B","ADD",37,52,"223/15"],["B","ADD",36,52,"-29/5"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/8"],["B","ADD",56,36,"1/8"],["B","ADD",57,36,"3/8"],["B","ADD",58,36,"1/8"],["B","ADD",60,36,"1/8"],["B","ADD",61,36,"3/8"],["B","ADD",62,36,"1/8"],["B","ADD",65,36,"1/4"],["B","SCALE",36,"-5/2"],["B","ADD",36,37,"3"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-10"],["B","ADD",36,54,"28"],["B","ADD",36,55,"8"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-10"],["B","ADD",36,58,"28"],["B","ADD",36,59,"8"],["B","ADD",36,60,"2"],["B","ADD",36,61,"-10"],["B","ADD",36,62,"28"],["B","ADD",36,63,"8"],["B","ADD",36,64,"2"],["B","IDLE_ONE",36,[10,9]],["B","ADD",36,64,"-2"],["B","ADD",36,63,"-8"],["B","ADD",36,62,"-28"],["B","ADD",36,61,"10"],["B","ADD",36,60,"-2"],["B","ADD",36,59,"-8"],["B","ADD",36,58,"-28"],["B","ADD",36,57,"10"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-8"],["B","ADD",36,54,"-28"],["B","ADD",36,53,"10"],["B","ADD",36,52,"-2"],["B","ADD",36,37,"-3"],["B","SCALE",36,"-2/5"],["B","ADD",65,36,"-1/4"],["B","ADD",62,36,"-1/8"],["B","ADD",61,36,"-3/8"],["B","ADD",60,36,"-1/8"],["B","ADD",58,36,"-1/8"],["B","ADD",57,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",54,36,"-1/8"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","ADD",60,36,"-1/4"],["B","ADD",61,36,"-1/4"],["B","ADD",63,36,"-1/4"],["B","ADD",64,36,"-1/2"],["B","SCALE",36,"5"],["B","ADD",36,37,"2"],["B","ADD",36,52,"8"],["B","ADD",36,53,"-20"],["B","ADD",36,54,"52"],["B","ADD",36,55,"12"],["B","ADD",36,56,"8"],["B","ADD",36,57,"-20"],["B","ADD",36,58,"52"],["B","ADD",36,59,"12"],["B","ADD",36,60,"8"],["B","ADD",36,61,"-20"],["B","ADD",36,62,"52"],["B","ADD",36,63,"12"],["B","ADD",36,64,"18"],["B","ADD",36,65,"-20"],["B","IDLE_ONE",36,[10,9]],["B","ADD",36,65,"20"],["B","ADD",36,64,"-18"],["B","ADD",36,63,"-12"],["B","ADD",36,62,"-52"],["B","ADD",36,61,"20"],["B","ADD",36,60,"-8"],["B","ADD",36,59,"-12"],["B","ADD",36,58,"-52"],["B","ADD",36,57,"20"],["B","ADD",36,56,"-8"],["B","ADD",36,55,"-12"],["B","ADD",36,54,"-52"],["B","ADD",36,53,"20"],["B","ADD",36,52,"-8"],["B","ADD",36,37,"-2"],["B","SCALE",36,"1/5"],["B","ADD",64,36,"1/2"],["B","ADD",63,36,"1/4"],["B","ADD",61,36,"1/4"],["B","ADD",60,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",57,36,"1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",37,36,"9/5"],["B","ADD",52,36,"-2/5"],["B","ADD",53,36,"-1/2"],["B","ADD",54,36,"-1/20"],["B","ADD",55,36,"-7/20"],["B","ADD",56,36,"-2/5"],["B","ADD",57,36,"-1/2"],["B","ADD",58,36,"-1/20"],["B","ADD",59,36,"-7/20"],["B","ADD",60,36,"-2/5"],["B","ADD",61,36,"-1/2"],["B","ADD",62,36,"-1/20"],["B","ADD",63,36,"-7/20"],["B","ADD",64,36,"-1/5"],["B","ADD",66,36,"-2/5"],["B","ADD",67,36,"7/40"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"-4"],["B","ADD",36,52,"-6"],["B","ADD",36,53,"20"],["B","ADD",36,54,"-54"],["B","ADD",36,55,"-14"],["B","ADD",36,56,"-6"],["B","ADD",36,57,"20"],["B","ADD",36,58,"-54"],["B","ADD",36,59,"-14"],["B","ADD",36,60,"-6"],["B","ADD",36,61,"20"],["B","ADD",36,62,"-54"],["B","ADD",36,63,"-14"],["B","ADD",36,64,"-6"],["B","ADD",36,65,"20"],["B","ADD",36,66,"40"],["B","ADD",36,67,"100"],["B","IDLE_ONE",36,[9]],["B","ADD",36,67,"-100"],["B","ADD",36,66,"-40"],["B","ADD",36,65,"-20"],["B","ADD",36,64,"6"],["B","ADD",36,63,"14"],["B","ADD",36,62,"54"],["B","ADD",36,61,"-20"],["B","ADD",36,60,"6"],["B","ADD",36,59,"14"],["B","ADD",36,58,"54"],["B","ADD",36,57,"-20"],["B","ADD",36,56,"6"],["B","ADD",36,55,"14"],["B","ADD",36,54,"54"],["B","ADD",36,53,"-20"],["B","ADD",36,52,"6"],["B","ADD",36,37,"4"],["B","SCALE",36,"-2"],["B","ADD",67,36,"-7/40"],["B","ADD",66,36,"2/5"],["B","ADD",64,36,"1/5"],["B","ADD",63,36,"7/20"],["B","ADD",62,36,"1/20"],["B","ADD",61,36,"1/2"],["B","ADD",60,36,"2/5"],["B","ADD",59,36,"7/20"],["B","ADD",58,36,"1/20"],["B","ADD",57,36,"1/2"],["B","ADD",56,36,"2/5"],["B","ADD",55,36,"7/20"],["B","ADD",54,36,"1/20"],["B","ADD",53,36,"1/2"],["B","ADD",52,36,"2/5"],["B","ADD",37,36,"-9/5"],["B","ADD",36,54,"-52/3"],["B","ADD",37,54,"92/3"],["B","ADD",52,54,"-22/3"],["B","ADD",53,54,"-28/3"],["B","ADD",55,54,"-19/3"],["B","ADD",56,54,"-22/3"],["B","ADD",57,54,"-28/3"],["B","ADD",58,54,"-1"],["B","ADD",59,54,"-19/3"],["B","ADD",60,54,"-22/3"],["B","ADD",61,54,"-28/3"],["B","ADD",62,54,"-1"],["B","ADD",63,54,"-19/3"],["B","ADD",64,54,"-8/3"],["B","ADD",65,54,"2/3"],["B","ADD",66,54,"-22/3"],["B","ADD",67,54,"3"],["B","SCALE",54,"-20/3"],["B","ADD",54,37,"2"],["B","ADD",54,52,"8"],["B","ADD",54,53,"-20"],["B","ADD",54,55,"12"],["B","ADD",54,56,"8"],["B","ADD",54,57,"-20"],["B","ADD",54,58,"52"],["B","ADD",54,59,"12"],["B","ADD",54,60,"8"],["B","ADD",54,61,"-20"],["B","ADD",54,62,"52"],["B","ADD",54,63,"12"],["B","ADD",54,64,"8"],["B","ADD",54,65,"-20"],["B","ADD",54,66,"-30"],["B","ADD",54,67,"-80"],["B","IDLE_ONE",54,[9]],["B","ADD",54,67,"80"],["B","ADD",54,66,"30"],["B","ADD",54,65,"20"],["B","ADD",54,64,"-8"],["B","ADD",54,63,"-12"],["B","ADD",54,62,"-52"],["B","ADD",54,61,"20"],["B","ADD",54,60,"-8"],["B","ADD",54,59,"-12"],["B","ADD",54,58,"-52"],["B","ADD",54,57,"20"],["B","ADD",54,56,"-8"],["B","ADD",54,55,"-12"],["B","ADD",54,53,"20"],["B","ADD",54,52,"-8"],["B","ADD",54,37,"-2"],["B","SCALE",54,"-3/20"],["B","ADD",67,54,"-3"],["B","ADD",66,54,"22/3"],["B","ADD",65,54,"-2/3"],["B","ADD",64,54,"8/3"],["B","ADD",63,54,"19/3"],["B","ADD",62,54,"1"],["B","ADD",61,54,"28/3"],["B","ADD",60,54,"22/3"],["B","ADD",59,54,"19/3"],["B","ADD",58,54,"1"],["B","ADD",57,54,"28/3"],["B","ADD",56,54,"22/3"],["B","ADD",55,54,"19/3"],["B","ADD",53,54,"28/3"],["B","ADD",52,54,"22/3"],["B","ADD",37,54,"-92/3"],["B","ADD",36,54,"52/3"],["B","IDLE_ODD",70,[9],-1],["B","IDLE_ODD",71,[9],-1],["B","ADD",37,36,"5/3"],["B","ADD",52,36,"-1/2"],["B","ADD",53,36,"-2/3"],["B","ADD",54,36,"-1/12"],["B","ADD",55,36,"-5/12"],["B","ADD",56,36,"-1/2"],["B","ADD",57,36,"-2/3"],["B","ADD",58,36,"-1/12"],["B","ADD",59,36,"-5/12"],["B","ADD",60,36,"-1/2"],["B","ADD",61,36,"-2/3"],["B","ADD",62,36,"-1/12"],["B","ADD",63,36,"-5/12"],["B","ADD",65,36,"1/6"],["B","ADD",66,36,"-2/3"],["B","ADD",67,36,"1/4"],["B","SCALE",36,"-1/3"],["B","ADD",36,37,"1"],["B","ADD",36,52,"-2"],["B","ADD",36,53,"2"],["B","ADD",36,54,"-4"],["B","ADD",36,56,"-2"],["B","ADD",36,57,"2"],["B","ADD",36,58,"-4"],["B","ADD",36,60,"-2"],["B","ADD",36,61,"2"],["B","ADD",36,62,"-4"],["B","ADD",36,64,"-2"],["B","ADD",36,65,"2"],["B","ADD",36,66,"-2"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-3/4"],["B","ADD",61,37,"-5/4"],["B","ADD",62,37,"-1/4"],["B","ADD",63,37,"-1/2"],["B","ADD",64,37,"3/2"],["B","ADD",65,37,"5/4"],["B","ADD",66,37,"-1/2"],["B","SCALE",37,"-3/4"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-3"],["B","ADD",37,55,"-1"],["B","ADD",37,57,"1"],["B","ADD",37,58,"-3"],["B","ADD",37,59,"-1"],["B","ADD",37,61,"1"],["B","ADD",37,62,"-3"],["B","ADD",37,63,"-1"],["B","ADD",37,65,"1"],["B","ADD",37,66,"2"],["B","ADD",37,67,"4"],["B","SCALE",37,"1"],["B","ADD",37,36,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",9,0,"1"],["A","ADD",10,0,"2"],["A","ADD",11,0,"2"],["A","ADD",12,0,"2"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",27,18,"1"],["A","ADD",28,18,"2"],["A","ADD",29,18,"2"],["A","ADD",30,18,"2"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",9,1],["A","LAMBDA",27,-1],["A","SCALE",27,"-1"],["J",9,[9,0,18,27],[36,37,"-1","1/2"]],["A","LAMBDA",9,-1],["A","LAMBDA",27,1],["A","SCALE",27,"-1"],["A","ADD",0,9,"-1"],["A","ADD",18,27,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-2"],["A","ADD",29,18,"-2"],["A","ADD",28,18,"-2"],["A","ADD",27,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-2"],["A","ADD",11,0,"-2"],["A","ADD",10,0,"-2"],["A","ADD",9,0,"-1"],["B","LAMBDA",36,-1],["B","ADD",37,36,"-1/2"],["B","SCALE",37,"1"],["B","ADD",37,67,"-4"],["B","ADD",37,66,"-2"],["B","ADD",37,65,"-1"],["B","ADD",37,63,"1"],["B","ADD",37,62,"3"],["B","ADD",37,61,"-1"],["B","ADD",37,59,"1"],["B","ADD",37,58,"3"],["B","ADD",37,57,"-1"],["B","ADD",37,55,"1"],["B","ADD",37,54,"3"],["B","ADD",37,53,"-1"],["B","SCALE",37,"-4/3"],["B","ADD",66,37,"1/2"],["B","ADD",65,37,"-5/4"],["B","ADD",64,37,"-3/2"],["B","ADD",63,37,"1/2"],["B","ADD",62,37,"1/4"],["B","ADD",61,37,"5/4"],["B","ADD",60,37,"3/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,66,"2"],["B","ADD",36,65,"-2"],["B","ADD",36,64,"2"],["B","ADD",36,62,"4"],["B","ADD",36,61,"-2"],["B","ADD",36,60,"2"],["B","ADD",36,58,"4"],["B","ADD",36,57,"-2"],["B","ADD",36,56,"2"],["B","ADD",36,54,"4"],["B","ADD",36,53,"-2"],["B","ADD",36,52,"2"],["B","ADD",36,37,"-1"],["B","SCALE",36,"-3"],["B","ADD",67,36,"-1/4"],["B","ADD",66,36,"2/3"],["B","ADD",65,36,"-1/6"],["B","ADD",63,36,"5/12"],["B","ADD",62,36,"1/12"],["B","ADD",61,36,"2/3"],["B","ADD",60,36,"1/2"],["B","ADD",59,36,"5/12"],["B","ADD",58,36,"1/12"],["B","ADD",57,36,"2/3"],["B","ADD",56,36,"1/2"],["B","ADD",55,36,"5/12"],["B","ADD",54,36,"1/12"],["B","ADD",53,36,"2/3"],["B","ADD",52,36,"1/2"],["B","ADD",37,36,"-5/3"],["B","ADD",37,36,"7/5"],["B","ADD",52,36,"-7/10"],["B","ADD",53,36,"-1"],["B","ADD",54,36,"-3/20"],["B","ADD",55,36,"-11/20"],["B","ADD",56,36,"-7/10"],["B","ADD",57,36,"-1"],["B","ADD",58,36,"-3/20"],["B","ADD",59,36,"-11/20"],["B","ADD",60,36,"-7/10"],["B","ADD",61,36,"-1"],["B","ADD",62,36,"-3/20"],["B","ADD",63,36,"-11/20"],["B","ADD",64,36,"2/5"],["B","ADD",65,36,"1/2"],["B","ADD",66,36,"-3/5"],["B","ADD",67,36,"1/5"],["B","SCALE",36,"-2"],["B","ADD",36,37,"-69"],["B","ADD",36,52,"-296"],["B","ADD",36,53,"730"],["B","ADD",36,54,"-1894"],["B","ADD",36,55,"-434"],["B","ADD",36,56,"-296"],["B","ADD",36,57,"730"],["B","ADD",36,58,"-1894"],["B","ADD",36,59,"-434"],["B","ADD",36,60,"-296"],["B","ADD",36,61,"730"],["B","ADD",36,62,"-1894"],["B","ADD",36,63,"-434"],["B","ADD",36,64,"-296"],["B","ADD",36,65,"730"],["B","ADD",36,66,"710"],["B","ADD",36,67,"1440"],["B","IDLE_ONE",36,[10]],["B","ADD",36,67,"-1440"],["B","ADD",36,66,"-710"],["B","ADD",36,65,"-730"],["B","ADD",36,64,"296"],["B","ADD",36,63,"434"],["B","ADD",36,62,"1894"],["B","ADD",36,61,"-730"],["B","ADD",36,60,"296"],["B","ADD",36,59,"434"],["B","ADD",36,58,"1894"],["B","ADD",36,57,"-730"],["B","ADD",36,56,"296"],["B","ADD",36,55,"434"],["B","ADD",36,54,"1894"],["B","ADD",36,53,"-730"],["B","ADD",36,52,"296"],["B","ADD",36,37,"69"],["B","SCALE",36,"-1/2"],["B","ADD",67,36,"-1/5"],["B","ADD",66,36,"3/5"],["B","ADD",65,36,"-1/2"],["B","ADD",64,36,"-2/5"],["B","ADD",63,36,"11/20"],["B","ADD",62,36,"3/20"],["B","ADD",61,36,"1"],["B","ADD",60,36,"7/10"],["B","ADD",59,36,"11/20"],["B","ADD",58,36,"3/20"],["B","ADD",57,36,"1"],["B","ADD",56,36,"7/10"],["B","ADD",55,36,"11/20"],["B","ADD",54,36,"3/20"],["B","ADD",53,36,"1"],["B","ADD",52,36,"7/10"],["B","ADD",37,36,"-7/5"],["B","ADD",36,55,"-11/6"],["B","ADD",37,55,"31/12"],["B","ADD",52,55,"-61/48"],["B","ADD",53,55,"-29/16"],["B","ADD",54,55,"-13/48"],["B","ADD",56,55,"-61/48"],["B","ADD",57,55,"-29/16"],["B","ADD",58,55,"-13/48"],["B","ADD",59,55,"-1"],["B","ADD",60,55,"-61/48"],["B","ADD",61,55,"-29/16"],["B","ADD",62,55,"-13/48"],["B","ADD",63,55,"-1"],["B","ADD",64,55,"17/24"],["B","ADD",65,55,"43/48"],["B","ADD",66,55,"-53/48"],["B","ADD",67,55,"143/384"],["B","SCALE",55,"5/48"],["B","ADD",55,37,"-2"],["B","ADD",55,52,"-8"],["B","ADD",55,53,"20"],["B","ADD",55,54,"-52"],["B","ADD",55,56,"-8"],["B","ADD",55,57,"20"],["B","ADD",55,58,"-52"],["B","ADD",55,59,"-12"],["B","ADD",55,60,"-8"],["B","ADD",55,61,"20"],["B","ADD",55,62,"-52"],["B","ADD",55,63,"-12"],["B","ADD",55,64,"-8"],["B","ADD",55,65,"20"],["B","ADD",55,66,"20"],["B","ADD",55,67,"40"],["B","IDLE_ONE",55,[10]],["B","ADD",55,67,"-40"],["B","ADD",55,66,"-20"],["B","ADD",55,65,"-20"],["B","ADD",55,64,"8"],["B","ADD",55,63,"12"],["B","ADD",55,62,"52"],["B","ADD",55,61,"-20"],["B","ADD",55,60,"8"],["B","ADD",55,59,"12"],["B","ADD",55,58,"52"],["B","ADD",55,57,"-20"],["B","ADD",55,56,"8"],["B","ADD",55,54,"52"],["B","ADD",55,53,"-20"],["B","ADD",55,52,"8"],["B","ADD",55,37,"2"],["B","SCALE",55,"48/5"],["B","ADD",67,55,"-143/384"],["B","ADD",66,55,"53/48"],["B","ADD",65,55,"-43/48"],["B","ADD",64,55,"-17/24"],["B","ADD",63,55,"1"],["B","ADD",62,55,"13/48"],["B","ADD",61,55,"29/16"],["B","ADD",60,55,"61/48"],["B","ADD",59,55,"1"],["B","ADD",58,55,"13/48"],["B","ADD",57,55,"29/16"],["B","ADD",56,55,"61/48"],["B","ADD",54,55,"13/48"],["B","ADD",53,55,"29/16"],["B","ADD",52,55,"61/48"],["B","ADD",37,55,"-31/12"],["B","ADD",36,55,"11/6"],["B","ADD",37,36,"3"],["B","ADD",52,36,"1/2"],["B","ADD",53,36,"1"],["B","ADD",54,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",56,36,"1/2"],["B","ADD",57,36,"1"],["B","ADD",58,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",60,36,"1/2"],["B","ADD",61,36,"1"],["B","ADD",62,36,"1/4"],["B","ADD",63,36,"1/4"],["B","ADD",64,36,"-2"],["B","ADD",65,36,"-3/2"],["B","ADD",67,36,"1/2"],["B","SCALE",36,"2"],["B","ADD",36,52,"4"],["B","ADD",36,53,"-8"],["B","ADD",36,54,"20"],["B","ADD",36,55,"4"],["B","ADD",36,56,"4"],["B","ADD",36,57,"-8"],["B","ADD",36,58,"20"],["B","ADD",36,59,"4"],["B","ADD",36,60,"4"],["B","ADD",36,61,"-8"],["B","ADD",36,62,"20"],["B","ADD",36,63,"4"],["B","ADD",36,64,"4"],["B","ADD",36,65,"-8"],["B","ADD",36,66,"-6"],["B","ADD",36,67,"-16"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-3/4"],["B","ADD",61,37,"-5/4"],["B","ADD",62,37,"-1/4"],["B","ADD",63,37,"-1/2"],["B","ADD",64,37,"3/2"],["B","ADD",65,37,"5/4"],["B","ADD",66,37,"-1/4"],["B","ADD",67,37,"-1/4"],["B","SCALE",37,"1/8"],["B","ADD",37,52,"-2"],["B","ADD",37,53,"7/2"],["B","ADD",37,54,"-17/2"],["B","ADD",37,55,"-3/2"],["B","ADD",37,56,"-2"],["B","ADD",37,57,"7/2"],["B","ADD",37,58,"-17/2"],["B","ADD",37,59,"-3/2"],["B","ADD",37,60,"-2"],["B","ADD",37,61,"7/2"],["B","ADD",37,62,"-17/2"],["B","ADD",37,63,"-3/2"],["B","ADD",37,64,"-2"],["B","ADD",37,65,"7/2"],["B","ADD",37,66,"1"],["B","ADD",37,67,"4"],["B","SCALE",37,"-2"],["B","ADD",37,36,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",10,0,"1"],["A","ADD",11,0,"2"],["A","ADD",12,0,"2"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",28,18,"1"],["A","ADD",29,18,"2"],["A","ADD",30,18,"2"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",10,1],["A","LAMBDA",28,-1],["A","SCALE",28,"-1"],["J",10,[10,0,18,28],[36,37,"-1","1/2"]],["A","LAMBDA",10,-1],["A","LAMBDA",28,1],["A","SCALE",28,"-1"],["A","ADD",0,10,"-1"],["A","ADD",18,28,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-2"],["A","ADD",29,18,"-2"],["A","ADD",28,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-2"],["A","ADD",11,0,"-2"],["A","ADD",10,0,"-1"],["B","LAMBDA",36,-1],["B","ADD",37,36,"1/2"],["B","SCALE",37,"-1/2"],["B","ADD",37,67,"-4"],["B","ADD",37,66,"-1"],["B","ADD",37,65,"-7/2"],["B","ADD",37,64,"2"],["B","ADD",37,63,"3/2"],["B","ADD",37,62,"17/2"],["B","ADD",37,61,"-7/2"],["B","ADD",37,60,"2"],["B","ADD",37,59,"3/2"],["B","ADD",37,58,"17/2"],["B","ADD",37,57,"-7/2"],["B","ADD",37,56,"2"],["B","ADD",37,55,"3/2"],["B","ADD",37,54,"17/2"],["B","ADD",37,53,"-7/2"],["B","ADD",37,52,"2"],["B","SCALE",37,"8"],["B","ADD",67,37,"1/4"],["B","ADD",66,37,"1/4"],["B","ADD",65,37,"-5/4"],["B","ADD",64,37,"-3/2"],["B","ADD",63,37,"1/2"],["B","ADD",62,37,"1/4"],["B","ADD",61,37,"5/4"],["B","ADD",60,37,"3/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,67,"16"],["B","ADD",36,66,"6"],["B","ADD",36,65,"8"],["B","ADD",36,64,"-4"],["B","ADD",36,63,"-4"],["B","ADD",36,62,"-20"],["B","ADD",36,61,"8"],["B","ADD",36,60,"-4"],["B","ADD",36,59,"-4"],["B","ADD",36,58,"-20"],["B","ADD",36,57,"8"],["B","ADD",36,56,"-4"],["B","ADD",36,55,"-4"],["B","ADD",36,54,"-20"],["B","ADD",36,53,"8"],["B","ADD",36,52,"-4"],["B","SCALE",36,"1/2"],["B","ADD",67,36,"-1/2"],["B","ADD",65,36,"3/2"],["B","ADD",64,36,"2"],["B","ADD",63,36,"-1/4"],["B","ADD",62,36,"-1/4"],["B","ADD",61,36,"-1"],["B","ADD",60,36,"-1/2"],["B","ADD",59,36,"-1/4"],["B","ADD",58,36,"-1/4"],["B","ADD",57,36,"-1"],["B","ADD",56,36,"-1/2"],["B","ADD",55,36,"-1/4"],["B","ADD",54,36,"-1/4"],["B","ADD",53,36,"-1"],["B","ADD",52,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",37,36,"2/3"],["B","ADD",52,36,"-5/4"],["B","ADD",53,36,"-23/12"],["B","ADD",54,36,"-1/3"],["B","ADD",55,36,"-11/12"],["B","ADD",56,36,"-5/4"],["B","ADD",57,36,"-23/12"],["B","ADD",58,36,"-1/3"],["B","ADD",59,36,"-11/12"],["B","ADD",60,36,"-5/4"],["B","ADD",61,36,"-23/12"],["B","ADD",62,36,"-1/3"],["B","ADD",63,36,"-11/12"],["B","ADD",64,36,"-1/3"],["B","SCALE",36,"2/3"],["B","ADD",36,37,"-12"],["B","ADD",36,52,"-52"],["B","ADD",36,53,"128"],["B","ADD",36,54,"-332"],["B","ADD",36,55,"-76"],["B","ADD",36,56,"-52"],["B","ADD",36,57,"128"],["B","ADD",36,58,"-332"],["B","ADD",36,59,"-76"],["B","ADD",36,60,"-52"],["B","ADD",36,61,"128"],["B","ADD",36,62,"-332"],["B","ADD",36,63,"-76"],["B","ADD",36,64,"-28"],["B","ADD",36,65,"76"],["B","IDLE_ONE",36,[11]],["B","ADD",36,65,"-76"],["B","ADD",36,64,"28"],["B","ADD",36,63,"76"],["B","ADD",36,62,"332"],["B","ADD",36,61,"-128"],["B","ADD",36,60,"52"],["B","ADD",36,59,"76"],["B","ADD",36,58,"332"],["B","ADD",36,57,"-128"],["B","ADD",36,56,"52"],["B","ADD",36,55,"76"],["B","ADD",36,54,"332"],["B","ADD",36,53,"-128"],["B","ADD",36,52,"52"],["B","ADD",36,37,"12"],["B","SCALE",36,"3/2"],["B","ADD",64,36,"1/3"],["B","ADD",63,36,"11/12"],["B","ADD",62,36,"1/3"],["B","ADD",61,36,"23/12"],["B","ADD",60,36,"5/4"],["B","ADD",59,36,"11/12"],["B","ADD",58,36,"1/3"],["B","ADD",57,36,"23/12"],["B","ADD",56,36,"5/4"],["B","ADD",55,36,"11/12"],["B","ADD",54,36,"1/3"],["B","ADD",53,36,"23/12"],["B","ADD",52,36,"5/4"],["B","ADD",37,36,"-2/3"],["B","ADD",36,53,"-14/27"],["B","ADD",37,53,"46/135"],["B","ADD",52,53,"-88/135"],["B","ADD",54,53,"-47/270"],["B","ADD",55,53,"-43/90"],["B","ADD",56,53,"-88/135"],["B","ADD",57,53,"-1"],["B","ADD",58,53,"-47/270"],["B","ADD",59,53,"-43/90"],["B","ADD",60,53,"-88/135"],["B","ADD",61,53,"-1"],["B","ADD",62,53,"-47/270"],["B","ADD",63,53,"-43/90"],["B","ADD",64,53,"-22/135"],["B","ADD",65,53,"1/135"],["B","SCALE",53,"-4/135"],["B","ADD",53,37,"-1"],["B","ADD",53,52,"-4"],["B","ADD",53,54,"-26"],["B","ADD",53,55,"-6"],["B","ADD",53,56,"-4"],["B","ADD",53,57,"10"],["B","ADD",53,58,"-26"],["B","ADD",53,59,"-6"],["B","ADD",53,60,"-4"],["B","ADD",53,61,"10"],["B","ADD",53,62,"-26"],["B","ADD",53,63,"-6"],["B","ADD",53,64,"-2"],["B","ADD",53,65,"6"],["B","IDLE_ONE",53,[11]],["B","ADD",53,65,"-6"],["B","ADD",53,64,"2"],["B","ADD",53,63,"6"],["B","ADD",53,62,"26"],["B","ADD",53,61,"-10"],["B","ADD",53,60,"4"],["B","ADD",53,59,"6"],["B","ADD",53,58,"26"],["B","ADD",53,57,"-10"],["B","ADD",53,56,"4"],["B","ADD",53,55,"6"],["B","ADD",53,54,"26"],["B","ADD",53,52,"4"],["B","ADD",53,37,"1"],["B","SCALE",53,"-135/4"],["B","ADD",65,53,"-1/135"],["B","ADD",64,53,"22/135"],["B","ADD",63,53,"43/90"],["B","ADD",62,53,"47/270"],["B","ADD",61,53,"1"],["B","ADD",60,53,"88/135"],["B","ADD",59,53,"43/90"],["B","ADD",58,53,"47/270"],["B","ADD",57,53,"1"],["B","ADD",56,53,"88/135"],["B","ADD",55,53,"43/90"],["B","ADD",54,53,"47/270"],["B","ADD",52,53,"88/135"],["B","ADD",37,53,"-46/135"],["B","ADD",36,53,"14/27"],["B","ADD",37,36,"3"],["B","ADD",52,36,"1/2"],["B","ADD",53,36,"1"],["B","ADD",54,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",56,36,"1/2"],["B","ADD",57,36,"1"],["B","ADD",58,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",60,36,"1/2"],["B","ADD",61,36,"1"],["B","ADD",62,36,"1/4"],["B","ADD",63,36,"1/4"],["B","ADD",65,36,"1/2"],["B","SCALE",36,"-2"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"8"],["B","ADD",36,54,"-20"],["B","ADD",36,55,"-4"],["B","ADD",36,56,"-4"],["B","ADD",36,57,"8"],["B","ADD",36,58,"-20"],["B","ADD",36,59,"-4"],["B","ADD",36,60,"-4"],["B","ADD",36,61,"8"],["B","ADD",36,62,"-20"],["B","ADD",36,63,"-4"],["B","ADD",36,64,"-6"],["B","ADD",36,65,"8"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-3/4"],["B","ADD",61,37,"-5/4"],["B","ADD",62,37,"-1/4"],["B","ADD",63,37,"-1/2"],["B","ADD",64,37,"-1/4"],["B","ADD",65,37,"-1/4"],["B","SCALE",37,"-1/8"],["B","ADD",37,52,"-2"],["B","ADD",37,53,"9/2"],["B","ADD",37,54,"-23/2"],["B","ADD",37,55,"-5/2"],["B","ADD",37,56,"-2"],["B","ADD",37,57,"9/2"],["B","ADD",37,58,"-23/2"],["B","ADD",37,59,"-5/2"],["B","ADD",37,60,"-2"],["B","ADD",37,61,"9/2"],["B","ADD",37,62,"-23/2"],["B","ADD",37,63,"-5/2"],["B","ADD",37,64,"-2"],["B","ADD",37,65,"5/2"],["B","SCALE",37,"2"],["B","ADD",37,36,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",11,0,"1"],["A","ADD",12,0,"2"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",29,18,"1"],["A","ADD",30,18,"2"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",11,1],["A","LAMBDA",29,-1],["A","SCALE",29,"-1"],["J",11,[11,0,18,29],[36,37,"-1","1/2"]],["A","LAMBDA",11,-1],["A","LAMBDA",29,1],["A","SCALE",29,"-1"],["A","ADD",0,11,"-1"],["A","ADD",18,29,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-2"],["A","ADD",29,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-2"],["A","ADD",11,0,"-1"],["B","LAMBDA",36,-1],["B","ADD",37,36,"1/2"],["B","SCALE",37,"1/2"],["B","ADD",37,65,"-5/2"],["B","ADD",37,64,"2"],["B","ADD",37,63,"5/2"],["B","ADD",37,62,"23/2"],["B","ADD",37,61,"-9/2"],["B","ADD",37,60,"2"],["B","ADD",37,59,"5/2"],["B","ADD",37,58,"23/2"],["B","ADD",37,57,"-9/2"],["B","ADD",37,56,"2"],["B","ADD",37,55,"5/2"],["B","ADD",37,54,"23/2"],["B","ADD",37,53,"-9/2"],["B","ADD",37,52,"2"],["B","SCALE",37,"-8"],["B","ADD",65,37,"1/4"],["B","ADD",64,37,"1/4"],["B","ADD",63,37,"1/2"],["B","ADD",62,37,"1/4"],["B","ADD",61,37,"5/4"],["B","ADD",60,37,"3/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,65,"-8"],["B","ADD",36,64,"6"],["B","ADD",36,63,"4"],["B","ADD",36,62,"20"],["B","ADD",36,61,"-8"],["B","ADD",36,60,"4"],["B","ADD",36,59,"4"],["B","ADD",36,58,"20"],["B","ADD",36,57,"-8"],["B","ADD",36,56,"4"],["B","ADD",36,55,"4"],["B","ADD",36,54,"20"],["B","ADD",36,53,"-8"],["B","ADD",36,52,"4"],["B","SCALE",36,"-1/2"],["B","ADD",65,36,"-1/2"],["B","ADD",63,36,"-1/4"],["B","ADD",62,36,"-1/4"],["B","ADD",61,36,"-1"],["B","ADD",60,36,"-1/2"],["B","ADD",59,36,"-1/4"],["B","ADD",58,36,"-1/4"],["B","ADD",57,36,"-1"],["B","ADD",56,36,"-1/2"],["B","ADD",55,36,"-1/4"],["B","ADD",54,36,"-1/4"],["B","ADD",53,36,"-1"],["B","ADD",52,36,"-1/2"],["B","ADD",37,36,"-3"],["B","ADD",36,52,"14"],["B","ADD",37,52,"-34"],["B","ADD",53,52,"-4"],["B","ADD",54,52,"-3/2"],["B","ADD",55,52,"1/2"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-4"],["B","ADD",58,52,"-3/2"],["B","ADD",59,52,"1/2"],["B","ADD",60,52,"-1"],["B","ADD",61,52,"-4"],["B","ADD",62,52,"-1/2"],["B","ADD",63,52,"1"],["B","SCALE",52,"-1"],["B","ADD",52,36,"1"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-6"],["B","ADD",52,54,"16"],["B","ADD",52,55,"4"],["B","ADD",52,56,"2"],["B","ADD",52,57,"-6"],["B","ADD",52,58,"16"],["B","ADD",52,59,"4"],["B","ADD",52,60,"2"],["B","ADD",52,61,"-6"],["B","ADD",52,62,"14"],["B","ADD",52,63,"6"],["B","IDLE_ONE",52,[12]],["B","ADD",52,63,"-6"],["B","ADD",52,62,"-14"],["B","ADD",52,61,"6"],["B","ADD",52,60,"-2"],["B","ADD",52,59,"-4"],["B","ADD",52,58,"-16"],["B","ADD",52,57,"6"],["B","ADD",52,56,"-2"],["B","ADD",52,55,"-4"],["B","ADD",52,54,"-16"],["B","ADD",52,53,"6"],["B","ADD",52,37,"-1"],["B","ADD",52,36,"-1"],["B","SCALE",52,"-1"],["B","ADD",63,52,"-1"],["B","ADD",62,52,"1/2"],["B","ADD",61,52,"4"],["B","ADD",60,52,"1"],["B","ADD",59,52,"-1/2"],["B","ADD",58,52,"3/2"],["B","ADD",57,52,"4"],["B","ADD",56,52,"1"],["B","ADD",55,52,"-1/2"],["B","ADD",54,52,"3/2"],["B","ADD",53,52,"4"],["B","ADD",37,52,"34"],["B","ADD",36,52,"-14"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/8"],["B","ADD",56,36,"1/8"],["B","ADD",57,36,"3/8"],["B","ADD",58,36,"1/8"],["B","ADD",60,36,"1/8"],["B","ADD",61,36,"3/8"],["B","ADD",62,36,"1/16"],["B","ADD",63,36,"-1/16"],["B","SCALE",36,"1/8"],["B","ADD",36,37,"-1"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"10"],["B","ADD",36,54,"-26"],["B","ADD",36,55,"-6"],["B","ADD",36,56,"-4"],["B","ADD",36,57,"10"],["B","ADD",36,58,"-26"],["B","ADD",36,59,"-6"],["B","ADD",36,60,"-4"],["B","ADD",36,61,"10"],["B","ADD",36,62,"-24"],["B","ADD",36,63,"-10"],["B","IDLE_ONE",36,[12]],["B","ADD",36,63,"10"],["B","ADD",36,62,"24"],["B","ADD",36,61,"-10"],["B","ADD",36,60,"4"],["B","ADD",36,59,"6"],["B","ADD",36,58,"26"],["B","ADD",36,57,"-10"],["B","ADD",36,56,"4"],["B","ADD",36,55,"6"],["B","ADD",36,54,"26"],["B","ADD",36,53,"-10"],["B","ADD",36,52,"4"],["B","ADD",36,37,"1"],["B","SCALE",36,"8"],["B","ADD",63,36,"1/16"],["B","ADD",62,36,"-1/16"],["B","ADD",61,36,"-3/8"],["B","ADD",60,36,"-1/8"],["B","ADD",58,36,"-1/8"],["B","ADD",57,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",54,36,"-1/8"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","SWAP",36,37],["B","ADD",52,36,"-3/4"],["B","ADD",53,36,"-5/4"],["B","ADD",54,36,"-1/4"],["B","ADD",55,36,"-1/2"],["B","ADD",56,36,"-3/4"],["B","ADD",57,36,"-5/4"],["B","ADD",58,36,"-1/4"],["B","ADD",59,36,"-1/2"],["B","ADD",60,36,"-3/4"],["B","ADD",61,36,"-5/4"],["B","ADD",62,36,"-1/4"],["B","ADD",63,36,"-1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"1"],["B","ADD",36,53,"-3"],["B","ADD",36,54,"8"],["B","ADD",36,55,"2"],["B","ADD",36,56,"1"],["B","ADD",36,57,"-3"],["B","ADD",36,58,"8"],["B","ADD",36,59,"2"],["B","ADD",36,60,"1"],["B","ADD",36,61,"-3"],["B","ADD",36,62,"6"],["B","ADD",36,63,"2"],["B","ADD",52,37,"-7/4"],["B","ADD",53,37,"-11/4"],["B","ADD",54,37,"-1/2"],["B","ADD",55,37,"-5/4"],["B","ADD",56,37,"-7/4"],["B","ADD",57,37,"-11/4"],["B","ADD",58,37,"-1/2"],["B","ADD",59,37,"-5/4"],["B","ADD",60,37,"-7/4"],["B","ADD",61,37,"-11/4"],["B","ADD",62,37,"-3/4"],["B","ADD",63,37,"-1/4"],["B","SCALE",37,"1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"1"],["B","ADD",37,58,"-2"],["B","ADD",37,60,"-1"],["B","ADD",37,61,"1"],["B","ADD",37,62,"-2"],["B","ADD",37,63,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",12,0,"1"],["A","ADD",13,0,"2"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",30,18,"1"],["A","ADD",31,18,"2"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",12,1],["A","LAMBDA",30,-1],["A","SCALE",30,"-1"],["J",12,[12,0,18,30],[36,37,"-1","1/2"]],["A","LAMBDA",12,-1],["A","LAMBDA",30,1],["A","SCALE",30,"-1"],["A","ADD",0,12,"-1"],["A","ADD",18,30,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-2"],["A","ADD",30,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-2"],["A","ADD",12,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,63,"2"],["B","ADD",37,62,"2"],["B","ADD",37,61,"-1"],["B","ADD",37,60,"1"],["B","ADD",37,58,"2"],["B","ADD",37,57,"-1"],["B","ADD",37,56,"1"],["B","ADD",37,54,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"2"],["B","ADD",63,37,"1/4"],["B","ADD",62,37,"3/4"],["B","ADD",61,37,"11/4"],["B","ADD",60,37,"7/4"],["B","ADD",59,37,"5/4"],["B","ADD",58,37,"1/2"],["B","ADD",57,37,"11/4"],["B","ADD",56,37,"7/4"],["B","ADD",55,37,"5/4"],["B","ADD",54,37,"1/2"],["B","ADD",53,37,"11/4"],["B","ADD",52,37,"7/4"],["B","ADD",36,63,"-2"],["B","ADD",36,62,"-6"],["B","ADD",36,61,"3"],["B","ADD",36,60,"-1"],["B","ADD",36,59,"-2"],["B","ADD",36,58,"-8"],["B","ADD",36,57,"3"],["B","ADD",36,56,"-1"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-8"],["B","ADD",36,53,"3"],["B","ADD",36,52,"-1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",63,36,"1/4"],["B","ADD",62,36,"1/4"],["B","ADD",61,36,"5/4"],["B","ADD",60,36,"3/4"],["B","ADD",59,36,"1/2"],["B","ADD",58,36,"1/4"],["B","ADD",57,36,"5/4"],["B","ADD",56,36,"3/4"],["B","ADD",55,36,"1/2"],["B","ADD",54,36,"1/4"],["B","ADD",53,36,"5/4"],["B","ADD",52,36,"3/4"],["B","SWAP",36,37],["B","ADD",37,36,"7/4"],["B","ADD",52,36,"-7/16"],["B","ADD",53,36,"-9/16"],["B","ADD",54,36,"-1/16"],["B","ADD",55,36,"-3/8"],["B","ADD",56,36,"-7/16"],["B","ADD",57,36,"-9/16"],["B","ADD",58,36,"-1/16"],["B","ADD",59,36,"-3/8"],["B","ADD",60,36,"-1/8"],["B","ADD",61,36,"1/4"],["B","SCALE",36,"-1/4"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-4"],["B","ADD",36,54,"10"],["B","ADD",36,55,"2"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-4"],["B","ADD",36,58,"10"],["B","ADD",36,59,"2"],["B","ADD",36,60,"2"],["B","ADD",36,61,"-2"],["B","IDLE_ONE",36,[13]],["B","ADD",36,61,"2"],["B","ADD",36,60,"-2"],["B","ADD",36,59,"-2"],["B","ADD",36,58,"-10"],["B","ADD",36,57,"4"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-10"],["B","ADD",36,53,"4"],["B","ADD",36,52,"-2"],["B","SCALE",36,"-4"],["B","ADD",61,36,"-1/4"],["B","ADD",60,36,"1/8"],["B","ADD",59,36,"3/8"],["B","ADD",58,36,"1/16"],["B","ADD",57,36,"9/16"],["B","ADD",56,36,"7/16"],["B","ADD",55,36,"3/8"],["B","ADD",54,36,"1/16"],["B","ADD",53,36,"9/16"],["B","ADD",52,36,"7/16"],["B","ADD",37,36,"-7/4"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","ADD",61,36,"1/2"],["B","ADD",36,37,"1"],["B","ADD",36,52,"4"],["B","ADD",36,53,"-10"],["B","ADD",36,54,"26"],["B","ADD",36,55,"6"],["B","ADD",36,56,"4"],["B","ADD",36,57,"-10"],["B","ADD",36,58,"26"],["B","ADD",36,59,"6"],["B","ADD",36,60,"2"],["B","ADD",36,61,"-6"],["B","IDLE_ONE",36,[13]],["B","ADD",36,61,"6"],["B","ADD",36,60,"-2"],["B","ADD",36,59,"-6"],["B","ADD",36,58,"-26"],["B","ADD",36,57,"10"],["B","ADD",36,56,"-4"],["B","ADD",36,55,"-6"],["B","ADD",36,54,"-26"],["B","ADD",36,53,"10"],["B","ADD",36,52,"-4"],["B","ADD",36,37,"-1"],["B","ADD",61,36,"-1/2"],["B","ADD",59,36,"1/4"],["B","ADD",57,36,"1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","ADD",60,36,"-1/4"],["B","ADD",61,36,"1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"-1"],["B","ADD",36,53,"1"],["B","ADD",36,54,"-2"],["B","ADD",36,56,"-1"],["B","ADD",36,57,"1"],["B","ADD",36,58,"-2"],["B","ADD",36,60,"-3"],["B","ADD",36,61,"1"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-3/4"],["B","ADD",57,37,"-5/4"],["B","ADD",58,37,"-1/4"],["B","ADD",59,37,"-1/2"],["B","ADD",60,37,"-1/4"],["B","ADD",61,37,"-1/4"],["B","SCALE",37,"-1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"3"],["B","ADD",37,54,"-8"],["B","ADD",37,55,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"3"],["B","ADD",37,58,"-8"],["B","ADD",37,59,"-2"],["B","ADD",37,60,"-1"],["B","ADD",37,61,"1"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",13,0,"1"],["A","ADD",14,0,"2"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",31,18,"1"],["A","ADD",32,18,"2"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",13,1],["A","LAMBDA",31,-1],["A","SCALE",31,"-1"],["J",13,[13,0,18,31],[36,37,"-1","1/2"]],["A","LAMBDA",13,-1],["A","LAMBDA",31,1],["A","SCALE",31,"-1"],["A","ADD",0,13,"-1"],["A","ADD",18,31,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-2"],["A","ADD",31,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-2"],["A","ADD",13,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,61,"-1"],["B","ADD",37,60,"1"],["B","ADD",37,59,"2"],["B","ADD",37,58,"8"],["B","ADD",37,57,"-3"],["B","ADD",37,56,"1"],["B","ADD",37,55,"2"],["B","ADD",37,54,"8"],["B","ADD",37,53,"-3"],["B","ADD",37,52,"1"],["B","SCALE",37,"-2"],["B","ADD",61,37,"1/4"],["B","ADD",60,37,"1/4"],["B","ADD",59,37,"1/2"],["B","ADD",58,37,"1/4"],["B","ADD",57,37,"5/4"],["B","ADD",56,37,"3/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,61,"-1"],["B","ADD",36,60,"3"],["B","ADD",36,58,"2"],["B","ADD",36,57,"-1"],["B","ADD",36,56,"1"],["B","ADD",36,54,"2"],["B","ADD",36,53,"-1"],["B","ADD",36,52,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",61,36,"-1/4"],["B","ADD",60,36,"1/4"],["B","ADD",59,36,"1/4"],["B","ADD",57,36,"1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",36,52,"14"],["B","ADD",37,52,"-34"],["B","ADD",53,52,"-4"],["B","ADD",54,52,"-3/2"],["B","ADD",55,52,"1/2"],["B","ADD",56,52,"-1"],["B","ADD",57,52,"-4"],["B","ADD",58,52,"-1/2"],["B","ADD",59,52,"1"],["B","SCALE",52,"-1"],["B","ADD",52,36,"1"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-6"],["B","ADD",52,54,"16"],["B","ADD",52,55,"4"],["B","ADD",52,56,"2"],["B","ADD",52,57,"-6"],["B","ADD",52,58,"14"],["B","ADD",52,59,"6"],["B","IDLE_ONE",52,[14]],["B","ADD",52,59,"-6"],["B","ADD",52,58,"-14"],["B","ADD",52,57,"6"],["B","ADD",52,56,"-2"],["B","ADD",52,55,"-4"],["B","ADD",52,54,"-16"],["B","ADD",52,53,"6"],["B","ADD",52,37,"-1"],["B","ADD",52,36,"-1"],["B","SCALE",52,"-1"],["B","ADD",59,52,"-1"],["B","ADD",58,52,"1/2"],["B","ADD",57,52,"4"],["B","ADD",56,52,"1"],["B","ADD",55,52,"-1/2"],["B","ADD",54,52,"3/2"],["B","ADD",53,52,"4"],["B","ADD",37,52,"34"],["B","ADD",36,52,"-14"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/8"],["B","ADD",56,36,"1/8"],["B","ADD",57,36,"3/8"],["B","ADD",58,36,"1/16"],["B","ADD",59,36,"-1/16"],["B","SCALE",36,"1/8"],["B","ADD",36,37,"-1"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"10"],["B","ADD",36,54,"-26"],["B","ADD",36,55,"-6"],["B","ADD",36,56,"-4"],["B","ADD",36,57,"10"],["B","ADD",36,58,"-24"],["B","ADD",36,59,"-10"],["B","IDLE_ONE",36,[14]],["B","ADD",36,59,"10"],["B","ADD",36,58,"24"],["B","ADD",36,57,"-10"],["B","ADD",36,56,"4"],["B","ADD",36,55,"6"],["B","ADD",36,54,"26"],["B","ADD",36,53,"-10"],["B","ADD",36,52,"4"],["B","ADD",36,37,"1"],["B","SCALE",36,"8"],["B","ADD",59,36,"1/16"],["B","ADD",58,36,"-1/16"],["B","ADD",57,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",54,36,"-1/8"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","SWAP",36,37],["B","ADD",52,36,"-3/4"],["B","ADD",53,36,"-5/4"],["B","ADD",54,36,"-1/4"],["B","ADD",55,36,"-1/2"],["B","ADD",56,36,"-3/4"],["B","ADD",57,36,"-5/4"],["B","ADD",58,36,"-1/4"],["B","ADD",59,36,"-1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"1"],["B","ADD",36,53,"-3"],["B","ADD",36,54,"8"],["B","ADD",36,55,"2"],["B","ADD",36,56,"1"],["B","ADD",36,57,"-3"],["B","ADD",36,58,"6"],["B","ADD",36,59,"2"],["B","ADD",52,37,"-7/4"],["B","ADD",53,37,"-11/4"],["B","ADD",54,37,"-1/2"],["B","ADD",55,37,"-5/4"],["B","ADD",56,37,"-7/4"],["B","ADD",57,37,"-11/4"],["B","ADD",58,37,"-3/4"],["B","ADD",59,37,"-1/4"],["B","SCALE",37,"1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"1"],["B","ADD",37,58,"-2"],["B","ADD",37,59,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",14,0,"1"],["A","ADD",15,0,"2"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",32,18,"1"],["A","ADD",33,18,"2"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",14,1],["A","LAMBDA",32,-1],["A","SCALE",32,"-1"],["J",14,[14,0,18,32],[36,37,"-1","1/2"]],["A","LAMBDA",14,-1],["A","LAMBDA",32,1],["A","SCALE",32,"-1"],["A","ADD",0,14,"-1"],["A","ADD",18,32,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-2"],["A","ADD",32,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-2"],["A","ADD",14,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,59,"2"],["B","ADD",37,58,"2"],["B","ADD",37,57,"-1"],["B","ADD",37,56,"1"],["B","ADD",37,54,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"2"],["B","ADD",59,37,"1/4"],["B","ADD",58,37,"3/4"],["B","ADD",57,37,"11/4"],["B","ADD",56,37,"7/4"],["B","ADD",55,37,"5/4"],["B","ADD",54,37,"1/2"],["B","ADD",53,37,"11/4"],["B","ADD",52,37,"7/4"],["B","ADD",36,59,"-2"],["B","ADD",36,58,"-6"],["B","ADD",36,57,"3"],["B","ADD",36,56,"-1"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-8"],["B","ADD",36,53,"3"],["B","ADD",36,52,"-1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",59,36,"1/4"],["B","ADD",58,36,"1/4"],["B","ADD",57,36,"5/4"],["B","ADD",56,36,"3/4"],["B","ADD",55,36,"1/2"],["B","ADD",54,36,"1/4"],["B","ADD",53,36,"5/4"],["B","ADD",52,36,"3/4"],["B","SWAP",36,37],["B","ADD",37,36,"7/4"],["B","ADD",52,36,"-7/16"],["B","ADD",53,36,"-9/16"],["B","ADD",54,36,"-1/16"],["B","ADD",55,36,"-3/8"],["B","ADD",56,36,"-1/8"],["B","ADD",57,36,"1/4"],["B","SCALE",36,"-1/4"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-4"],["B","ADD",36,54,"10"],["B","ADD",36,55,"2"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-2"],["B","IDLE_ONE",36,[15]],["B","ADD",36,57,"2"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-10"],["B","ADD",36,53,"4"],["B","ADD",36,52,"-2"],["B","SCALE",36,"-4"],["B","ADD",57,36,"-1/4"],["B","ADD",56,36,"1/8"],["B","ADD",55,36,"3/8"],["B","ADD",54,36,"1/16"],["B","ADD",53,36,"9/16"],["B","ADD",52,36,"7/16"],["B","ADD",37,36,"-7/4"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",57,36,"1/2"],["B","ADD",36,37,"1"],["B","ADD",36,52,"4"],["B","ADD",36,53,"-10"],["B","ADD",36,54,"26"],["B","ADD",36,55,"6"],["B","ADD",36,56,"2"],["B","ADD",36,57,"-6"],["B","IDLE_ONE",36,[15]],["B","ADD",36,57,"6"],["B","ADD",36,56,"-2"],["B","ADD",36,55,"-6"],["B","ADD",36,54,"-26"],["B","ADD",36,53,"10"],["B","ADD",36,52,"-4"],["B","ADD",36,37,"-1"],["B","ADD",57,36,"-1/2"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","ADD",56,36,"-1/4"],["B","ADD",57,36,"1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"-1"],["B","ADD",36,53,"1"],["B","ADD",36,54,"-2"],["B","ADD",36,56,"-3"],["B","ADD",36,57,"1"],["B","ADD",52,37,"-3/4"],["B","ADD",53,37,"-5/4"],["B","ADD",54,37,"-1/4"],["B","ADD",55,37,"-1/2"],["B","ADD",56,37,"-1/4"],["B","ADD",57,37,"-1/4"],["B","SCALE",37,"-1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"3"],["B","ADD",37,54,"-8"],["B","ADD",37,55,"-2"],["B","ADD",37,56,"-1"],["B","ADD",37,57,"1"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",15,0,"1"],["A","ADD",16,0,"2"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",33,18,"1"],["A","ADD",34,18,"2"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",15,1],["A","LAMBDA",33,-1],["A","SCALE",33,"-1"],["J",15,[15,0,18,33],[36,37,"-1","1/2"]],["A","LAMBDA",15,-1],["A","LAMBDA",33,1],["A","SCALE",33,"-1"],["A","ADD",0,15,"-1"],["A","ADD",18,33,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-2"],["A","ADD",33,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-2"],["A","ADD",15,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,57,"-1"],["B","ADD",37,56,"1"],["B","ADD",37,55,"2"],["B","ADD",37,54,"8"],["B","ADD",37,53,"-3"],["B","ADD",37,52,"1"],["B","SCALE",37,"-2"],["B","ADD",57,37,"1/4"],["B","ADD",56,37,"1/4"],["B","ADD",55,37,"1/2"],["B","ADD",54,37,"1/4"],["B","ADD",53,37,"5/4"],["B","ADD",52,37,"3/4"],["B","ADD",36,57,"-1"],["B","ADD",36,56,"3"],["B","ADD",36,54,"2"],["B","ADD",36,53,"-1"],["B","ADD",36,52,"1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",57,36,"-1/4"],["B","ADD",56,36,"1/4"],["B","ADD",55,36,"1/4"],["B","ADD",53,36,"1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","ADD",36,52,"14"],["B","ADD",37,52,"-34"],["B","ADD",53,52,"-4"],["B","ADD",54,52,"-1/2"],["B","ADD",55,52,"1"],["B","SCALE",52,"-1"],["B","ADD",52,36,"1"],["B","ADD",52,37,"1"],["B","ADD",52,53,"-6"],["B","ADD",52,54,"14"],["B","ADD",52,55,"6"],["B","IDLE_ONE",52,[16]],["B","ADD",52,55,"-6"],["B","ADD",52,54,"-14"],["B","ADD",52,53,"6"],["B","ADD",52,37,"-1"],["B","ADD",52,36,"-1"],["B","SCALE",52,"-1"],["B","ADD",55,52,"-1"],["B","ADD",54,52,"1/2"],["B","ADD",53,52,"4"],["B","ADD",37,52,"34"],["B","ADD",36,52,"-14"],["B","ADD",37,36,"5/2"],["B","ADD",52,36,"1/8"],["B","ADD",53,36,"3/8"],["B","ADD",54,36,"1/16"],["B","ADD",55,36,"-1/16"],["B","SCALE",36,"1/8"],["B","ADD",36,37,"-1"],["B","ADD",36,52,"-4"],["B","ADD",36,53,"10"],["B","ADD",36,54,"-24"],["B","ADD",36,55,"-10"],["B","IDLE_ONE",36,[16]],["B","ADD",36,55,"10"],["B","ADD",36,54,"24"],["B","ADD",36,53,"-10"],["B","ADD",36,52,"4"],["B","ADD",36,37,"1"],["B","SCALE",36,"8"],["B","ADD",55,36,"1/16"],["B","ADD",54,36,"-1/16"],["B","ADD",53,36,"-3/8"],["B","ADD",52,36,"-1/8"],["B","ADD",37,36,"-5/2"],["B","SWAP",36,37],["B","ADD",52,36,"-3/4"],["B","ADD",53,36,"-5/4"],["B","ADD",54,36,"-1/4"],["B","ADD",55,36,"-1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"1"],["B","ADD",36,53,"-3"],["B","ADD",36,54,"6"],["B","ADD",36,55,"2"],["B","ADD",52,37,"-7/4"],["B","ADD",53,37,"-11/4"],["B","ADD",54,37,"-3/4"],["B","ADD",55,37,"-1/4"],["B","SCALE",37,"1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","ADD",37,54,"-2"],["B","ADD",37,55,"-2"],["B","SCALE",37,"-1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",16,0,"1"],["A","ADD",17,0,"2"],["A","SCALE",0,"-1"],["A","ADD",34,18,"1"],["A","ADD",35,18,"2"],["A","SCALE",18,"-1"],["A","LAMBDA",16,1],["A","LAMBDA",34,-1],["A","SCALE",34,"-1"],["J",16,[16,0,18,34],[36,37,"-1","1/2"]],["A","LAMBDA",16,-1],["A","LAMBDA",34,1],["A","SCALE",34,"-1"],["A","ADD",0,16,"-1"],["A","ADD",18,34,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-2"],["A","ADD",34,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-2"],["A","ADD",16,0,"-1"],["B","LAMBDA",36,-1],["B","SCALE",37,"-2"],["B","ADD",37,55,"2"],["B","ADD",37,54,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"2"],["B","ADD",55,37,"1/4"],["B","ADD",54,37,"3/4"],["B","ADD",53,37,"11/4"],["B","ADD",52,37,"7/4"],["B","ADD",36,55,"-2"],["B","ADD",36,54,"-6"],["B","ADD",36,53,"3"],["B","ADD",36,52,"-1"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",55,36,"1/4"],["B","ADD",54,36,"1/4"],["B","ADD",53,36,"5/4"],["B","ADD",52,36,"3/4"],["B","SWAP",36,37],["B","ADD",37,36,"7/4"],["B","ADD",52,36,"-1/8"],["B","ADD",53,36,"1/4"],["B","SCALE",36,"-1/4"],["B","ADD",36,37,"-1"],["B","ADD",36,53,"4"],["B","IDLE_ONE",36,[17]],["B","ADD",36,53,"-4"],["B","ADD",36,37,"1"],["B","SCALE",36,"-4"],["B","ADD",53,36,"-1/4"],["B","ADD",52,36,"1/8"],["B","ADD",37,36,"-7/4"],["B","ADD",37,36,"5/3"],["B","ADD",52,36,"-1/6"],["B","ADD",53,36,"1/6"],["B","SCALE",36,"-1/3"],["B","ADD",36,37,"1"],["B","ADD",36,52,"2"],["B","ADD",36,53,"-6"],["B","IDLE_ONE",36,[17]],["B","ADD",36,53,"6"],["B","ADD",36,52,"-2"],["B","ADD",36,37,"-1"],["B","SCALE",36,"-3"],["B","ADD",53,36,"-1/6"],["B","ADD",52,36,"1/6"],["B","ADD",37,36,"-5/3"],["B","ADD",37,36,"2"],["B","ADD",52,36,"-1/4"],["B","ADD",53,36,"1/4"],["B","SCALE",36,"-1/2"],["B","ADD",36,37,"1/2"],["B","ADD",36,52,"-3"],["B","ADD",36,53,"1"],["B","ADD",52,37,"-1/4"],["B","ADD",53,37,"-1/4"],["B","SCALE",37,"-1/2"],["B","ADD",37,52,"-1"],["B","ADD",37,53,"1"],["B","SCALE",37,"1/2"],["B","ADD",37,36,"-1/2"],["B","ADD",36,37,"1"],["B","LAMBDA",36,1],["A","ADD",17,0,"1"],["A","SCALE",0,"-1"],["A","ADD",35,18,"1"],["A","SCALE",18,"-1"],["A","LAMBDA",17,1],["A","LAMBDA",35,-1],["A","SCALE",35,"-1"],["J",17,[17,0,18,35],[36,37,"-1","1/2"]],["A","LAMBDA",17,-1],["A","LAMBDA",35,1],["A","SCALE",35,"-1"],["A","ADD",0,17,"-1"],["A","ADD",18,35,"-1"],["A","SCALE",18,"-1"],["A","ADD",35,18,"-1"],["A","SCALE",0,"-1"],["A","ADD",17,0,"-1"],["A","LAMBDA",0,-1],["A","LAMBDA",1,-1],["A","LAMBDA",2,-1],["A","LAMBDA",3,-1],["A","LAMBDA",4,-1],["A","LAMBDA",5,-1],["A","LAMBDA",6,-1],["A","LAMBDA",7,-1],["A","LAMBDA",8,-1],["A","LAMBDA",9,-1],["A","LAMBDA",10,-1],["A","LAMBDA",11,-1],["A","LAMBDA",12,-1],["A","LAMBDA",13,-1],["A","LAMBDA",14,-1],["A","LAMBDA",15,-1],["A","LAMBDA",16,-1],["A","LAMBDA",17,-1],["A","LAMBDA",18,-1],["A","LAMBDA",19,-1],["A","LAMBDA",20,-1],["A","LAMBDA",21,-1],["A","LAMBDA",22,-1],["A","LAMBDA",23,-1],["A","LAMBDA",24,-1],["A","LAMBDA",25,-1],["A","LAMBDA",26,-1],["A","LAMBDA",27,-1],["A","LAMBDA",28,-1],["A","LAMBDA",29,-1],["A","LAMBDA",30,-1],["A","LAMBDA",31,-1],["A","LAMBDA",32,-1],["A","LAMBDA",33,-1],["A","LAMBDA",34,-1],["A","LAMBDA",35,-1],["B","LAMBDA",36,-1],["B","SCALE",37,"2"],["B","ADD",37,53,"-1"],["B","ADD",37,52,"1"],["B","SCALE",37,"-2"],["B","ADD",53,37,"1/4"],["B","ADD",52,37,"1/4"],["B","ADD",36,53,"-1"],["B","ADD",36,52,"3"],["B","ADD",36,37,"-1/2"],["B","SCALE",36,"-2"],["B","ADD",53,36,"-1/4"],["B","ADD",52,36,"1/4"],["B","ADD",37,36,"-2"],["B","LAMBDA",36,-1],["B","LAMBDA",37,-1],["B","LAMBDA",38,-1],["B","LAMBDA",39,-1],["B","LAMBDA",40,-1],["B","LAMBDA",41,-1],["B","LAMBDA",42,-1],["B","LAMBDA",43,-1],["B","LAMBDA",44,-1],["B","LAMBDA",45,-1],["B","LAMBDA",46,-1],["B","LAMBDA",47,-1],["B","LAMBDA",48,-1],["B","LAMBDA",49,-1],["B","LAMBDA",50,-1],["B","LAMBDA",51,-1],["B","LAMBDA",52,-1],["B","LAMBDA",53,-1],["B","LAMBDA",54,-1],["B","LAMBDA",55,-1],["B","LAMBDA",56,-1],["B","LAMBDA",57,-1],["B","LAMBDA",58,-1],["B","LAMBDA",59,-1],["B","LAMBDA",60,-1],["B","LAMBDA",61,-1],["B","LAMBDA",62,-1],["B","LAMBDA",63,-1],["B","LAMBDA",64,-1],["B","LAMBDA",65,-1],["B","LAMBDA",66,-1],["B","LAMBDA",67,-1]],"ops_note":"QSELF(x, k): R[x] *= q^k, one paid rank-1 job on one register (new op; not in the retained alphabet).; source interval457..575 replaced by a three-QUERY even-basis factorization; no QSELF"} \ No newline at end of file diff --git a/research/p104-finite-monomial-decoder-bound/inputs/native/RESULT.json b/research/p104-finite-monomial-decoder-bound/inputs/native/RESULT.json new file mode 100644 index 0000000000..b1d7b3d4a2 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/inputs/native/RESULT.json @@ -0,0 +1,1599 @@ +{ + "adapter": { + "adapted_sha256": { + "check_odd_partial_admission.py": "f47b0324ceb14f739d82d00ce7e5e3af579d18a0456fe4df33d50a4b7cd46bff", + "check_odd_precision.py": "2c0316767a823c80172779486292f1e32a98811ed56c58dea3f2fda59ea82969", + "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.003645372367832')", + "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) == (70, 49, 67)')\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()}" + } + ] + }, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "catalogue": [ + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "430c467e9c73ef00ddc325b7cf95aba8a34187f362eae67791aafd26b117e4b9", + "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": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "2cae048f253c10a701476eaa4486931f22766daf994d44d80688b0f8f2fc530f", + "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": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "c8524029578adf6749ecc9b72b848a9933ea23b54951d7349c0614c18603fea9", + "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": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 36, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "01651736571052e77f70be25553d3f726b5325a89c93cb9459a54c3634ee1f38", + "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": 3036, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + } + ], + "checks": { + "ODD-8X9-APPLICATION-CHECKS.json": { + "assumptions": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "candidate": "455671545979/125000000000000", + "catalogue": [ + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "430c467e9c73ef00ddc325b7cf95aba8a34187f362eae67791aafd26b117e4b9", + "log_sha256": "6044e9f8fbc626fb4ce26ee150982501db458a720ccb442336a357ecbedf8cbf", + "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": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "2cae048f253c10a701476eaa4486931f22766daf994d44d80688b0f8f2fc530f", + "log_sha256": "7a69868003dbbebe8f13be7a85471d7948a64a7aff8fb4a43ba8f2d15650922a", + "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": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 1000, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "c8524029578adf6749ecc9b72b848a9933ea23b54951d7349c0614c18603fea9", + "log_sha256": "c4f22893254b9723eae8e347d3c306ed217ede766432f023fd3777ff1dfc1d3e", + "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": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + }, + { + "catalogue_digest": "789580be599f2c712cda0ef0622d3fff6c86bf1ffdcd49c73b2f7f839aae5f23", + "catalogue_size": 3036, + "checked_maps": 36, + "distinct_helper_maps": 187, + "distinct_paid_maps": 2950, + "exact_recipe_digest": "01651736571052e77f70be25553d3f726b5325a89c93cb9459a54c3634ee1f38", + "log_sha256": "1ba0cc2396f28f900bc4421f907ca48568f6bbb0492501dc0c615338ae1375bf", + "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": 3036, + "status": "PASS_CURRENT_NATIVE_CATALOGUE_SLICE", + "word_sha256": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f" + } + ], + "fixed_tape_counts": { + "H": 16510400000000000000000, + "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": 25483363264, + "log_power": 2237, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298876, + "native_invocations": 17, + "native_sha256": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "owned_banks_per_raw_occurrence": 1139, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58522, + "native": 1192771 + }, + "scalar_services_upper": 43812768, + "scalar_steps_coefficient": 45941017018368, + "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": "455671545979/125000000000000" + }, + "native_archive_sha256": "75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f", + "native_canonical_sha256": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "numeric_gate": { + "BIT_margin": "12131763216793/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16510400000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "455671545979/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.90793784170701, + 0.90793784170701 + ], + "derivative_upper": -381639.64893454965, + "gamma": [ + 0.9407239445039388, + 0.9407239445039388 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364537236783207/100000000000000000": [ + "62185957815160823955634035200379287232048672826724207991903601034269062476013/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62185957815160823955634035200379287232048672826724207991903601034269062476983/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455671545979/125000000000000": [ + "124371915630319361575544177418824499406336810029819480064104520884248806236771/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124371915630319361575544177418824499406336810029819480064104520884248806238699/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2236, + "moment_margin_float": { + "364537236783207/100000000000000000": [ + 2.4613808499256653e-10, + 2.4613808499256653e-10 + ], + "36453723678327048470293552676013/10000000000000000000000000000000000": [ + -1.2587526364330572e-29, + -1.2587526364330572e-29 + ], + "9113430919581762117573388169003/2500000000000000000000000000000000": [ + 2.618371672434497e-29, + 2.618371672434497e-29 + ] + }, + "moment_margins": { + "364537236783207/100000000000000000": [ + "12306904249628325984866401717755904031793776121193530007029514944773881/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "6153452124814162992433200858877952015896888060596765003514757482054647/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36453723678327048470293552676013/10000000000000000000000000000000000": [ + "-251750527286611434637589720125802971981646634050597/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1258752636433057173187948600629014859908233131273333/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9113430919581762117573388169003/2500000000000000000000000000000000": [ + "2618371672434497331862416099184509798828989402912189/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2618371672434497331862416099184509798828989441794841/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "9113430919581762117573388169003/2500000000000000000000000000000000", + "36453723678327048470293552676013/10000000000000000000000000000000000" + ], + "tested": "364537236783207/100000000000000000", + "written_log_power": 2237 + }, + "physical_binding": { + "ambient": 145, + "complete_paid_position_digest": "6e8d8c7c33e2f2997157a2bdf1861afe7ae59970c26b029203f8cc797caadd5f", + "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": 68401, + "16": 416, + "2": 14501, + "24": 416, + "3": 14093, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 238, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "paid_positions": 110553, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22461, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 1139, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3808, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 561, + "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": 782539276, + "init_clear_allowance": 280, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 217460724, + "odd_divisions": { + "ADD": 5829, + "SCALE": 71 + }, + "per_input_conversion": 2653768, + "raw_upper": 765877348, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2202, + "moves": 6281, + "owned_lifetime": 280, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9963000, + "scalar_upper": 2192236 + }, + "status": "PASS_8X9_EXACT_COMPONENT_APPLICATION_CHECKS" + }, + "ODD-ADMISSION-PARTIAL.json": { + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "compiler_outer": { + "BIT_margin": "12131763216793/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16510400000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "455671545979/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.90793784170701, + 0.90793784170701 + ], + "derivative_upper": -381639.64893454965, + "gamma": [ + 0.9407239445039388, + 0.9407239445039388 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364537236783207/100000000000000000": [ + "62185957815160823955634035200379287232048672826724207991903601034269062476013/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62185957815160823955634035200379287232048672826724207991903601034269062476983/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455671545979/125000000000000": [ + "124371915630319361575544177418824499406336810029819480064104520884248806236771/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124371915630319361575544177418824499406336810029819480064104520884248806238699/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2236, + "moment_margin_float": { + "364537236783207/100000000000000000": [ + 2.4613808499256653e-10, + 2.4613808499256653e-10 + ], + "36453723678327048470293552676013/10000000000000000000000000000000000": [ + -1.2587526364330572e-29, + -1.2587526364330572e-29 + ], + "9113430919581762117573388169003/2500000000000000000000000000000000": [ + 2.618371672434497e-29, + 2.618371672434497e-29 + ] + }, + "moment_margins": { + "364537236783207/100000000000000000": [ + "12306904249628325984866401717755904031793776121193530007029514944773881/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "6153452124814162992433200858877952015896888060596765003514757482054647/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36453723678327048470293552676013/10000000000000000000000000000000000": [ + "-251750527286611434637589720125802971981646634050597/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1258752636433057173187948600629014859908233131273333/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9113430919581762117573388169003/2500000000000000000000000000000000": [ + "2618371672434497331862416099184509798828989402912189/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2618371672434497331862416099184509798828989441794841/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "9113430919581762117573388169003/2500000000000000000000000000000000", + "36453723678327048470293552676013/10000000000000000000000000000000000" + ], + "tested": "364537236783207/100000000000000000", + "written_log_power": 2237 + }, + "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": 68401, + "16": 416, + "2": 14501, + "24": 416, + "3": 14093, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 238, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3808, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 561, + "9": 10888 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036453723678327048470293552676012675338592174074882354127105617063", + "raw_crossing": "0.0036453723678327048470293552676012675338592174074882354127105617063" + }, + "native_sha256": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "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": 782539276, + "init_clear_allowance": 280, + "lambda_paid_rank1_would_reduce_S_by": 11280, + "lambda_second_charge": 11280000, + "margin_to_billion": 217460724, + "odd_divisions": { + "ADD": 5829, + "SCALE": 71 + }, + "per_input_conversion": 2653768, + "raw_upper": 765877348, + "route_items": { + "first_main_adapter": 416, + "first_main_boundary": 208, + "helper_boundary": 2202, + "moves": 6281, + "owned_lifetime": 280, + "second_main_adapter": 384, + "second_main_boundary": 192 + }, + "routing": 9963000, + "scalar_upper": 2192236 + }, + "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": 16510400000000000000000, + "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": 25483363264, + "log_power": 2237, + "max_scalar_numerator_bits": 24, + "monomial_map_slots": 298876, + "native_invocations": 17, + "native_sha256": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "owned_banks_per_raw_occurrence": 1139, + "scalar_macro_inputs": { + "caller": 117856, + "conversions": 58522, + "native": 1192771 + }, + "scalar_services_upper": 43812768, + "scalar_steps_coefficient": 45941017018368, + "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": "455671545979/125000000000000" + }, + "ODD-PHYSICAL-BINDING.json": { + "aliased_main_rejected": true, + "caller_sha256": "255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc", + "native_sha256": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "occurrence_and_geometry": { + "ambient": 145, + "complete_paid_position_digest": "6e8d8c7c33e2f2997157a2bdf1861afe7ae59970c26b029203f8cc797caadd5f", + "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": 68401, + "16": 416, + "2": 14501, + "24": 416, + "3": 14093, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 238, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "paid_positions": 110553, + "phase_record_digest": "586ab7499fb677afdd83c397ea0b6d3b25f73ea6cdfa1ec95dd68adccff935ad", + "productive_fields": 22461, + "query_uses": 384, + "rank_surplus": 1424, + "reserved_native_banks": 1139, + "reserved_serial_query_lambda_bank": 1, + "targets": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3808, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 561, + "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": 16448741, + "dyadic_height": 25, + "mass_witness": [ + 66212, + "stored add" + ], + "maximum_scaled_mass": "841374570120675/8192", + "numerator_bits": 24, + "odd_scale_lcm": 1125 + }, + "native_sha256": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "precision_program_sha256": "6828598610ad0b8e73083d1a5126f4e485698f6f519a60767598c0c52c71b060", + "rounded_caller": { + "bounds": { + "E_joint_entrance": { + "exact": "3700391395634398193988231961413106626231788248633761228620292774210365782787301892502881857188967421229788558531795090284669944481562871272089169063323223118899737430616075842451477229329858459087069358439424353636706012107417837501998279396747241562770127882774179009175731866055605237955830754806524366496861425985439696129569974520646754983463570989655434669687361756257004229576891093516341979785535966529241995500433628988435907161449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "strict_power_of_two": 1179, + "witness": { + "cut": 4691, + "event": 4691, + "factor": "1", + "kind": "stored", + "register": 36 + } + }, + "Gamma_context": { + "exact": "95498228877481792407732094667731188460316260455601654554478634712165643366226038426898592633343708499777390969750393393307168108872678662471755270069754483315413258199707248837262419789838145639631347041591826680613421546094257959998730332766800121001732874336297113930240135178308947324920420661315915179767111349051346301872512147496799227136275051881583816665511687235906426881166624122765376299866715287088977839543216923821028131663779/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": "981854199274791633791257137686278843099997480379185914860705438687120456804937961897636886077339221004995032694141063631661436117749900209868597623913611620536251993564450326605732023663083560027696392573388123134524356046358364719758969967433380655644557757798580660749122760664642338995776803810874820300987852570269504055866798900872168946458420363638308421864453951305305470229552912639581896762622538762187236908574007777183884745665260157/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": "95498228877481792407732094667731188460316260455601654554478634712165643366226038426898592633343708499777390969750393393307168108872678662471755270069754483315413258199707248837262419789838145639631347041591826680613421546094257959998730332766800121001732874336297113930240135178308947324920420661315915179767111349051346301872512147496799227136275051881583816665511687235906426881166624122765376299866715287088977839543216923821028131663779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000", + "strict_power_of_two": 1184, + "witness": { + "cut": 4753, + "event": 4752, + "factor": "1", + "kind": "stored", + "register": 37 + } + }, + "Sigma_context": { + "exact": "291908632640396543147239251769182815765347850305725022201049394692891850169052702221813985095582575585024897788234996046676951373886345119746482333087919439248405281122826697709149277233201578238516215022983549467536629621326560874712371221311728165186634487529959118831594619392072881671530648530586205967550672277583504274330392501119504187417088136394898597421780662126485689779288622968013288913245939892490167784544400369839195640690643002934108060566331911266750050318232614013958979022758282901530775873980494375510591749274208641614579262333922748768538395077508169057448621695483/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": "3700391395634398193988231961413106626231788248633761228620292774210365782787301892502881857188967421229788558531795090284669944481562871272089169063323223118899737430616075842451477229329858459087069358439424353636706012107417837501998279396747241562770127882774179009175731866055605237955830754806524366496861425985439696129569974520646754983463570989655434669687361756257004229576891093516341979785535966529241995500433628988435907161449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000" + }, + "Gamma_context": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "95498228877481792407732094667731188460316260455601654554478634712165643366226038426898592633343708499777390969750393393307168108872678662471755270069754483315413258199707248837262419789838145639631347041591826680613421546094257959998730332766800121001732874336297113930240135178308947324920420661315915179767111349051346301872512147496799227136275051881583816665511687235906426881166624122765376299866715287088977839543216923821028131663779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000" + }, + "M_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796247824792255124449682067424881/131368167114257812500000000000", + "residual_mass": "95498228877481792407732094667731188460316260455601654554478634712165643366226038426898592633343708499777390969750393393307168108872678662471755270069754483315413258199707248837262419789838145639631347041591826680613421546094257959998730332766800121001732874336297113930240135178308947324920420661315915179767111349051346301872512147496799227136275051881583350491069705048064400774481801244344384299866715287088977839543216923821028131663779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000" + }, + "M_joint_entrance": { + "entrance_mass": "12446513821466013746992171114880354528234540647439407368041740746722705684890095694539586093101687855496797040728247169012299728404791642365323413178973703529222728715961384485250463009966565309368602073434714550373752128374887698957802006867751735225949803848812917591840288770078529478244705471/608185958862304687500000000", + "joint_coefficient": "144218124282401204617230263054514744346632405857442589144991781917530152132889870002846209306787762894150543865356389849084238452276894627352790762454037345126994351979907477144401257368423063007427271766117739822282248246858569624239109891511459830034432108241771054783468611278140179030295737/14596463012695312500000000000", + "primitive_coefficient": "1237373204913668966810008103424843603237049842106979534739539344726881600855129275554334885562896567825503574055929527662143657491595081161117482238618339640110136792453314323518006796600687371906278112102741547626404362403105174332310591538741639237757093806525664195341657589882317257470101709011/175157556152343750000000000000", + "residual_mass": "3700391395634398193988231961413106626231788248633761228620292774210365782787301892502881857188967421229788558531795090284669944481562871272089169063323223118899737430616075842451477229329858459087069358439424353636706012107417837501998279396747241562770127882774179009175731866055605237955830754806524366496861425985439696129569974520646754983463570989655434669687361756257004229576891093516341979785535966529241995500433628988435907161449/621565922642917122701475579763837894656000000000000000000000000000000000000000000000" + }, + "Sigma_caller": { + "entrance_mass": "321214676655933560129782836030951119958622429471431692811117505066079252658303325303661828534046786576018850667853596288128047313819788006911616028348392581085050721023636971054851673799947587501432346122953175312809813833001587100311020687804583808767060460431114911369649528995555025426696059541/456139469146728515625000000", + "joint_coefficient": "3721923971948022264020008386608472289590988528157114268392412469599050143495508978788641788787976594161440706214373829555996384554677122174093932095769106055424540710380314024651007332164525664382203471694821380954416641216321248248752759218861172626274920078125266851782731337714997593665899027/10947347259521484375000000000", + "primitive_coefficient": "31933635363307317503891208167952125518099265598871297188945655447689887409437080424471754322893069036961252717295444311531802702290424391181977246033332095685934810861449534911850277930109610390733877602745069385156892357266512877411313922547610591253415658016844390796379192959369382262182067424881/131368167114257812500000000000", + "residual_mass": "95498228877481792407732094667731188460316260455601654554478634712165643366226038426898592633343708499777390969750393393307168108872678662471755270069754483315413258199707248837262419789838145639631347041591826680613421546094257959998730332766800121001732874336297113930240135178308947324920420661315915179767111349051346301872512147496799227136275051881583816665511687235906426881166624122765376299866715287088977839543216923821028131663779/466174441982187842026106684822878420992000000000000000000000000000000000000000000000" + } + }, + "joint_entries": [ + { + "entrance_defect": "1435/4", + "entrance_mass": "2067/2", + "event": 43, + "stage": 1 + }, + { + "entrance_defect": "44014421449424002110213101873304075005919476994513296298024761326887228027069257925851965577937955681769744363636999920067582903024343331433046863003039/13307288940955860965151791568755097600000000000000000000", + "entrance_mass": "56849465528/5", + "event": 137, + "stage": 2 + }, + { + "entrance_defect": "66875161162342788504236192740396175870454756755693173515453543710978772135235489043419675837044574521689019581390791260360151766373991850348813828222488903598906399/1277499738331762652654571990600489369600000000000000000000", + "entrance_mass": "899756300051784928313/5", + "event": 268, + "stage": 3 + }, + { + "entrance_defect": "62287829181073555448314854637831594222496382201083494725957560734823785336923277431942010710892419530881063648412949308838152985024858605687044367703147205503340111949136607/1277499738331762652654571990600489369600000000000000000000", + "entrance_mass": "2514111326902273689027625979152/15", + "event": 432, + "stage": 4 + }, + { + "entrance_defect": "12723996845476725541154302647350247270857469337040138950674128979681026401707653678951757626320728832229674726066337291467309727774715245951892643205693204752171205942061922083282166297/1277499738331762652654571990600489369600000000000000000000", + "entrance_mass": "513576167499541081817002847690160861158177/15", + "event": 633, + "stage": 5 + }, + { + "entrance_defect": "1218322501347303928216200172712737774246782535762919133177499853680429749688418864091481091541261914275651621607113236423177532961026146741688465535395354911417757307641484193871295496001148458373/19162496074976439789818579859007340544000000000000000000000", + "entrance_mass": "49174910102467876864090432969907258581035345395534834/225", + "event": 867, + "stage": 6 + }, + { + "entrance_defect": "129940314273901234900495220450642513175133460422743216171998552787711781971649084776273354473336524697292302362254821286296179568877299782520203972762446660649100085021257322399592194535798694152898334189323/2129166230552937754424286651000815616000000000000000000000", + "entrance_mass": "47202796791779792903787260464709452698419616298153732189406926691/225", + "event": 1138, + "stage": 7 + }, + { + "entrance_defect": "37833342518003692030801232854911423070139033702432086754567502381265112179915373106082028316025257283704950589708118552266529872222645097797898542758925345959472986223757915682137846920803078562183711861076373993493198505117/2395312009372054973727322482375917568000000000000000000000000", + "entrance_mass": "1527059719525243651854937925515623170877847518562264265010551055991429949116792541/28125", + "event": 1423, + "stage": 8 + }, + { + "entrance_defect": "13492230945974542935771030245134195880207837253704954008374659691637345470177544675269665701112595875741751170769468752082417783857577944215817629164541772434155058212139811450161892211159159100593022939587547930095684325764894634124512467053625054086651503968454326765393503868206616000720321237078775932977408861752651551769578084984834485598303380429072657/2762515211746298323117669243394835087360000000000000000000000000000000000000000000", + "entrance_mass": "45382020709918266925583064268574418985484021788023395083741971786893952543604385214817042722264713249357732585113211736557042182118473445437784492974844696068231496289005681248244219743195326431922663592509646282903/2703048706054687500000000", + "event": 3058, + "stage": 9 + }, + { + "entrance_defect": "5130439558410158112007682408089895237937641135696220254931857260054179126172163024792466918680934177180188106985147625782234042862716242285600170913123615859031062575676253497204454819179393980023771602590443471583886105558224631591023675801479338494884110520274655114411091087557832492302686450398821313192508070150700489854836587058562489144274451920503455550341747641803/69062880293657458077941731084870877184000000000000000000000000000000000000000000000", + "entrance_mass": "17256576412236653193246225901973714737195067836439327666112948810725372605325768521068989782195051084826433423902219365061463548934152577319772447024097669813834215493691840531234110147024064996639957180865886380686899413865699437/67576217651367187500000000", + "event": 3377, + "stage": 10 + }, + { + "entrance_defect": "2447659884876748969061470001154570021719221801643259648188430480348673481305794995629467029061768418486842625107342023154557583438333080171791116304408641100208649549773805492064093780350319381940081534106834040960354793955507345606353116969162708160405766023259320332641546007685199111299595174429806969874540104783055964035264907567778725206319238863591481705101743201609499381818857/2302096009788581935931391036162362572800000000000000000000000000000000000000000000", + "entrance_mass": "8232867642949280967953864719378369729636081542640965177026582834276172086852779069019078166383458700724373015543641299678854718814560615654710102550769670203427726502361438450768012893674227975469242856299447027845030556012745339827937032703/2252540588378906250000000", + "event": 3674, + "stage": 11 + }, + { + "entrance_defect": "30758305108508113436939905613290518481871233068983603178035022079322127858437955175046573596584427514542549795721995383222060448096496036718316434449548104956243254345352804084848421084138778049135870043403601463594856504870946252004270128303044648028596509512084735343336107585124599659747344288608923729967723515475634584971674322113649348419814644644926396995633292400626901760686761975617812489/310782961321458561350737789881918947328000000000000000000000000000000000000000000000", + "entrance_mass": "103457615351059805192637231353494210876529187337645013912367786609511281374638184501291799844537790265462481580051228205479278831706979374022592427678836083146990308179368316797029946556942233864286312243671687806427572314354434738422294564686254956597631/304092979431152343750000000", + "event": 3934, + "stage": 12 + }, + { + "entrance_defect": "2026029986081447564193823977052871737274467997318767984745880792357813081128603909891449483864309254853302482388032620823463592576454614258557874935119960821411771949651082932385348330202154462334495146432178378322468910065945437724456391506048315227224183547346417547709292990463739401905033648642531172592475644989322271698487553050480656376080330343323161931575428500534903457028796775237040898155511241/77695740330364640337684447470479736832000000000000000000000000000000000000000000000", + "entrance_mass": "6814687293408352348961376609223100753789665399854180217091951198766673494955017243489117504312576625705862588971333049204842152193259763726092611947454717867967563820647006231530855513792517852570389360287582421241328472893443552787136426885585158158296407747039/76023244857788085937500000", + "event": 4149, + "stage": 13 + }, + { + "entrance_defect": "81368552078924056650019386854496386022445855114287818696253312823951925553976322246138069846097791635428052422794528683253941650460390556630226664221017246105893208178686663735462101737512412570263406196224140985649687560585685088466145459862228685133428783492223588442515251751157290522234734425041551590787482605463883014544914152594180228615487354735175850378441348437878886692516381950167525860521687781911639729/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "entrance_mass": "273688564209132230699064882255651065961520374651451250325109091529813162250488973700796593555467744131430272845604649750549608356985710665121874068107850799585492748533787927289567936649257940207702597871193107311090132538524151482351564937285621850171994049078063458209591/608185958862304687500000000", + "event": 4337, + "stage": 14 + }, + { + "entrance_defect": "1555129075560279792560833953758080959076484652577478041426651661747278426554568937666787252095915009231723464775979133244983049545260829184342041379800578829693582194511022204381799499008912289468655249533079705163635365796441058192846576979671494554515507060005954331001031672049183131686018974981843589051280188124529854237939070870659388864022118359123946883521384518618049950324776072918522300068932566789596138834145659/310782961321458561350737789881918947328000000000000000000000000000000000000000000000", + "entrance_mass": "5230780602279043381317572379439763694807653157987526423412516241866438709931406455512285461654380762978554988724296151241130161368896505647624919395909388513302452136334767445346454946237326490486725295589968816639097338790755366202380875008783642473174121062695038054202858248061/304092979431152343750000000", + "event": 4485, + "stage": 15 + }, + { + "entrance_defect": "1721513013742678354123234387431046665054234314062025384505354464047852086760747219083198910024469429708903099426771383236874163479585753194349525300714804825361912153891656300874372530723547189079227103675023573685305042925708100103169702423787925888355402137457359592622222648654909003950866520521084430185556016366861135510389260181209469461820168867993266341720730462020558871407753482018012838505886797438688117704018140597320697/621565922642917122701475579763837894656000000000000000000000000000000000000000000000", + "entrance_mass": "5790424100720951765768300756324298709533962301792798636386692749870979029496708556989270788662796627612885676197810930990877069943243536093513215980405080279750566239442965631097385199413957318608000177913047677092759213914423460784984181631621622445055356552059259436283593839861423838063/608185958862304687500000000", + "event": 4606, + "stage": 16 + }, + { + "entrance_defect": "3700391395634398193988231961413106626231788248633761228620292774210365782787301892502881857188967421229788558531795090284669944481562871272089169063323223118899737430616075842451477229329858459087069358439424353636706012107417837501998279396747241562770127882774179009175731866055605237955830754806524366496861425985439696129569974520646754983463570989655434669687361756257004229576891093516341979785535966529241995500433628988435907161449/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": "25658296514718665663724761455038993665013304128124285547409309468182902382390451901998717126354748415780818755968047984253654522668231697453168177/42583324611058755088485733020016312320000000000000000000", + "strict_power_of_two": 299, + "witness": { + "cut": 76444, + "factor": "1", + "kind": "public-return", + "register": 1498 + } + }, + "M": { + "exact": "78885880284118292076998717719781876096347665647824497567470757539679832954370746877506446595824785784526303648069065087019557498698445175282954441667/9084442583692534418876956377603479961600000000000000000000", + "strict_power_of_two": 303, + "witness": { + "cut": 76416, + "factor": "1", + "kind": "stored", + "register": 1498 + } + }, + "Sigma": { + "exact": "25658296514718665663724761455038993665013304128124285547409309468182902382390451901998717126354748415780818755968047984253654522668231697453168177/42583324611058755088485733020016312320000000000000000000", + "strict_power_of_two": 299, + "witness": { + "cut": 76416, + "factor": "1", + "kind": "stored", + "register": 1498 + } + } + }, + "census": { + "denominator_bits": 20, + "events": 76444, + "lifetimes": 70, + "max_denominator": 655360, + "max_numerator": 14729531, + "numerator_bits": 24, + "opcodes": { + "ADD": 66296, + "CLEAR": 70, + "COPY": 1, + "INIT": 70, + "MOVE": 6281, + "SCALE": 3726 + }, + "owned_labels": 67, + "peak_owned": 49, + "public": 1501, + "scalars": { + "dyadic": 64123, + "integer": 39769, + "noninteger": 30254, + "odd": 5900 + } + }, + "independent_adjoint": { + "Gamma": { + "active_residual_sites": 26564, + "entrance_mass": "78885880284118292076998717719781876096347665647824497567470757539679832954370746877506446595824785784526303648069065087019557498698445175282954441667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25658296514718665663724761455038993665013304128124285547409309468182902382390451901998717126354748415780818755968047984253654522668231697453168177/42583324611058755088485733020016312320000000000000000000" + }, + "M": { + "active_residual_sites": 26564, + "entrance_mass": "78885880284118292076998717719781876096347665647824497567470757539679832954370746877506446595824785784526303648069065087019557498698445175282954441667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25658296514718665663724761455038993665013304128124285547409309468182902382390451901998717126354748415780818755968047984253654522668231697453168177/42583324611058755088485733020016312320000000000000000000" + }, + "Sigma": { + "active_residual_sites": 26564, + "entrance_mass": "78885880284118292076998717719781876096347665647824497567470757539679832954370746877506446595824785784526303648069065087019557498698445175282954441667/9084442583692534418876956377603479961600000000000000000000", + "residual_mass": "25658296514718665663724761455038993665013304128124285547409309468182902382390451901998717126354748415780818755968047984253654522668231697453168177/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": 68401, + "16": 416, + "2": 14501, + "24": 416, + "3": 14093, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 238, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "raw_bracket": [ + "9113430919581762117573388169003/2500000000000000000000000000000000", + "36453723678327048470293552676013/10000000000000000000000000000000000" + ], + "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": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "target": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3808, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 561, + "9": 10888 + } + } + }, + "claim": "455671545979/125000000000000", + "price": { + "after": { + "P": { + "1": 68401, + "16": 416, + "2": 14501, + "24": 416, + "3": 14093, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 238, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "S": 1424, + "T": { + "1": 306, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3808, + "41": 416, + "49": 416, + "5": 1360, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 561, + "9": 10888 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036453723678327048470293552676012675338592174074882354127105617063", + "raw_crossing": "0.0036453723678327048470293552676012675338592174074882354127105617063" + }, + "before": { + "P": { + "1": 68367, + "16": 416, + "2": 14501, + "24": 416, + "3": 14093, + "32": 416, + "4": 3825, + "40": 416, + "48": 416, + "5": 5848, + "56": 416, + "6": 238, + "64": 208, + "7": 170, + "8": 741, + "9": 32 + }, + "S": 1424, + "T": { + "1": 289, + "137": 208, + "17": 416, + "2": 357, + "25": 416, + "3": 799, + "33": 416, + "4": 3791, + "41": 416, + "49": 416, + "5": 1343, + "57": 416, + "6": 731, + "65": 416, + "7": 323, + "73": 208, + "8": 578, + "9": 10888 + }, + "empty_root_credits": 0, + "no_E_credit_crossing": "0.0036448900679400754544078619670439199509193901914957386128030283655", + "raw_crossing": "0.0036448900679400754544078619670439199509193901914957386128030283655" + }, + "gate": { + "BIT_margin": "12131763216793/100000000000000000", + "BIT_pin": "376669/100000000", + "H": "16510400000000000000000", + "alpha": [ + 0.9999999999999991, + 0.9999999999999991 + ], + "claim": "455671545979/125000000000000", + "compiler_gap": "1/100000000000000000", + "delta": [ + 0.90793784170701, + 0.90793784170701 + ], + "derivative_upper": -381639.64893454965, + "gamma": [ + 0.9407239445039388, + 0.9407239445039388 + ], + "input_lift": { + "derivative_upper_on_required_interval": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "interval_kappa_cap": "376669/100000000", + "margins": { + "364537236783207/100000000000000000": [ + "62185957815160823955634035200379287232048672826724207991903601034269062476013/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "62185957815160823955634035200379287232048672826724207991903601034269062476983/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "455671545979/125000000000000": [ + "124371915630319361575544177418824499406336810029819480064104520884248806236771/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "124371915630319361575544177418824499406336810029819480064104520884248806238699/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "source_BIT_wide_crude_bound_would_be": "-2299831290525933154178526076272396899996972093654613095735772838275432653960006518819/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000" + }, + "minimum_log_power": 2236, + "moment_margin_float": { + "364537236783207/100000000000000000": [ + 2.4613808499256653e-10, + 2.4613808499256653e-10 + ], + "36453723678327048470293552676013/10000000000000000000000000000000000": [ + -1.2587526364330572e-29, + -1.2587526364330572e-29 + ], + "9113430919581762117573388169003/2500000000000000000000000000000000": [ + 2.618371672434497e-29, + 2.618371672434497e-29 + ] + }, + "moment_margins": { + "364537236783207/100000000000000000": [ + "12306904249628325984866401717755904031793776121193530007029514944773881/50000000000000000000000000000000000000000000000000000000000000000000000000000000", + "6153452124814162992433200858877952015896888060596765003514757482054647/25000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "36453723678327048470293552676013/10000000000000000000000000000000000": [ + "-251750527286611434637589720125802971981646634050597/20000000000000000000000000000000000000000000000000000000000000000000000000000000", + "-1258752636433057173187948600629014859908233131273333/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "9113430919581762117573388169003/2500000000000000000000000000000000": [ + "2618371672434497331862416099184509798828989402912189/100000000000000000000000000000000000000000000000000000000000000000000000000000000", + "2618371672434497331862416099184509798828989441794841/100000000000000000000000000000000000000000000000000000000000000000000000000000000" + ] + }, + "outer": { + "BIT_just_below_effective_rejected": true, + "functional_count": 4, + "minimum_margin": "1/1000000000000000000", + "strict_count": 54 + }, + "raw_bracket": [ + "9113430919581762117573388169003/2500000000000000000000000000000000", + "36453723678327048470293552676013/10000000000000000000000000000000000" + ], + "tested": "364537236783207/100000000000000000", + "written_log_power": 2237 + }, + "native_baseline_rejects_new_claim": true, + "new_native": "56e1a5e60cecf14991b3169b4575f0b7388d48fa39f261d7a20c7627a8d9e540", + "old_native": "9eff91418d838f1ffa20fe5c5975dc2c43a79b32d501fcbe30b90c50a7b11ce3", + "price": { + "baseline_rejects_new_claim": true, + "candidate_margin_at_old_upper": [ + "4674846229174353838106472780847644835169217331401720998231748096453090876820727/25000000000000000000000000000000000000000000000000000000000000000000000000000000", + "9349692458348707676212945561695289670338434662803441996463496192906181770848171/50000000000000000000000000000000000000000000000000000000000000000000000000000000" + ], + "claim_decimal": "0.003645372367832", + "gain": "4.82299892E-7", + "gain_exact": "120574973/250000000000000", + "independent_raw_bracket": [ + "0.00364537236783270484702935526760126", + "0.00364537236783270484702935526760127" + ], + "previous_claim": "182244503397/50000000000000", + "raw_bracket": [ + "0.0036453723678327048470293552676012", + "0.0036453723678327048470293552676013" + ] + } + }, + "status": "PASS_TWO_CUT_FUNDED_CALLER" +} diff --git a/research/p104-finite-monomial-decoder-bound/inputs/native/WORD.json.gz b/research/p104-finite-monomial-decoder-bound/inputs/native/WORD.json.gz new file mode 100644 index 0000000000..836f915b72 Binary files /dev/null and b/research/p104-finite-monomial-decoder-bound/inputs/native/WORD.json.gz differ diff --git a/research/p104-finite-monomial-decoder-bound/replay.py b/research/p104-finite-monomial-decoder-bound/replay.py new file mode 100644 index 0000000000..92cf0b1ef4 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/replay.py @@ -0,0 +1,158 @@ +"""Reproduce the exact typed stock, source availability and finite-arm gates.""" + +import argparse +from hashlib import sha256 +import json +import shutil +from pathlib import Path, PurePosixPath +import subprocess +import sys +from tempfile import TemporaryDirectory + +FROZEN = { + 'TWO-ARM.json': (233402, '92095d8281ee0c895aafee22092c21786d905948ace6fdf2902bc7f0642eb408'), + 'TYPED.json': (4875219, '68202ba9326938cb0bf5abbabb893c3db01090a22acb6ba55afaef1dbae2bf9c'), + 'GATE.json': (465446, 'd047446188cd0bb93c5835a536560dc6509e8369e774c017e0f4a63c98cdc61d'), +} +SCRIPTS = frozenset({ + 'typed_stock.py', 'decode_gate.py', 'audit.py', + 'two_arm_gate.py', 'audit_two_arm.py', +}) +REPLAY_FILES = SCRIPTS | { + 'AUDIT.json', + 'TWO-ARM-AUDIT.json', + 'contracts/PROOF.md', + 'contracts/SOURCES.json', + 'contracts/canonical-PROOF-REVIEW.md', + 'contracts/pr7161-PROOF.md', + 'CAP-ONE.json', + 'SUMMARY.json', + 'deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py', + 'deps/canonical/research/shared-wire-split-composition/frozen/native_verify.py', + 'deps/round11/frontier/independent_adapter_price.py', + 'deps/round13/alternative/reprice.py', + 'deps/round20/complex-stock/stock.py', + 'inputs/caller/CALLER.json', + 'inputs/native/RESULT.json', + 'inputs/native/WORD.json.gz', +} +TYPED_KEYS = ( + 'source_head', 'source_tree', 'target', 'cap', 'stop_reason', 'status', 'moves_checked', + 'moves_pending', 'original_paid_positions', 'original_productive_targets', 'stages', + 'row_groups', 'target_cosets', 'eligible_groups', 'eligible_members', 'eligible_member_hist', + 'skipped_child_hist', 'baseline', 'raw_margin_upper', 'complete_saving_interval', +) +GATE_KEYS = ( + 'head', 'target', 'scope', 'status', 'stop_reason', 'max_seconds', 'tested_pairs', + 'total_pairs', 'completed_groups', 'pending_groups', 'passed_by_mode', 'eligible_groups_by_mode', + 'pending_ideal_hist', 'price_one_retained', 'price_overgrant_multiple_retained', + 'controls', 'site_tests', +) + + +def summary(typed_raw, gate_raw): + typed, gate = json.loads(typed_raw), json.loads(gate_raw) + return { + 'typed_stock': {key: typed[key] for key in TYPED_KEYS}, + 'source_availability': {key: gate[key] for key in GATE_KEYS}, + 'survivor_counts': {key: len(rows) for key, rows in gate['survivors'].items()}, + 'receipts': { + name: {'bytes': len(raw), 'sha256': sha256(raw).hexdigest()} + for name, raw in [('TYPED.json', typed_raw), ('GATE.json', gate_raw)] + }, + } + + +def stage(root, inputs, deps, scratch): + seen = set() + bases = {'inputs': inputs, 'deps': deps} + for row in (root / 'REPLAY.sha256').read_text(encoding='ascii').splitlines(): + digest, key = row.split(' ', 1) + rel = PurePosixPath(key) + if rel.as_posix() != key or key not in REPLAY_FILES or key in seen: + raise ValueError(f'Unexpected or duplicate replay path: {key}') + seen.add(key) + base = bases.get(rel.parts[0]) + path = root / rel if base is None else base.joinpath(*rel.parts[1:]) + raw = path.read_bytes() + if sha256(raw).hexdigest() != digest: + raise ValueError(f'SHA-256 mismatch: {key}') + if base is not None or key in SCRIPTS or rel.parts[0] == 'contracts': + target = scratch / rel + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(raw) + if seen != REPLAY_FILES: + raise ValueError(f'Missing replay paths: {sorted(REPLAY_FILES - seen)}') + + +def call(root, script, args=(), expect_ok=True): + command = [sys.executable, '-I', '-B', str(root / script), str(root), *args] + result = subprocess.run(command, capture_output=True, check=False) + if expect_ok and (result.returncode or result.stderr): + sys.stderr.buffer.write(result.stderr) + raise ValueError(f'{script} did not finish cleanly (exit {result.returncode})') + return result + + +def exact_receipt(scratch, name, script, args): + raw = call(scratch, script, args).stdout + if (len(raw), sha256(raw).hexdigest()) != FROZEN[name]: + raise ValueError(f'Byte mismatch: generated {name}') + (scratch / name).write_bytes(raw) + return raw + + +def controls(root, scratch, gate_raw): + cap = call(scratch, 'typed_stock.py', ('--cap', '1', '--seconds', '480')).stdout + if cap != (root / 'CAP-ONE.json').read_bytes(): + raise ValueError('Byte mismatch: CAP-ONE.json') + gate = json.loads(gate_raw) + circular = gate['survivors']['support_any_original_resident'] + assert circular and not gate['survivors']['support_independent_original_resident'] + gate['survivors']['support_independent_original_resident'] = circular[:1] + (scratch / 'GATE.json').write_text(json.dumps(gate), encoding='utf-8') + mutant = call(scratch, 'audit.py', expect_ok=False) + expected = b"assert not gate['survivors']['support_independent_original_resident']" + if mutant.returncode != 1 or mutant.stdout or expected not in mutant.stderr: + raise ValueError('Independent audit did not reject the forged surviving source') + print('PASS_CAP_ONE_PENDING_AND_FORGED_SOURCE_REJECTION') + + +def main(): + if not __debug__ or sys.implementation.name != 'cpython' or sys.version_info[:2] != (3, 12): + raise ValueError('Use CPython 3.12 with assertions enabled') + root = Path(__file__).resolve().parent + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--inputs', type=Path, default=root / 'inputs') + parser.add_argument('--deps', type=Path, default=root / 'deps') + parser.add_argument('--controls', action='store_true') + args = parser.parse_args() + with TemporaryDirectory(prefix='typed-arm-') as name: + scratch = Path(name) + stage(root, args.inputs.resolve(), args.deps.resolve(), scratch) + typed = exact_receipt(scratch, 'TYPED.json', 'typed_stock.py', ('--cap', '6281', '--seconds', '480')) + gate = exact_receipt(scratch, 'GATE.json', 'decode_gate.py', ('--seconds', '180')) + if summary(typed, gate) != json.loads((root / 'SUMMARY.json').read_text(encoding='utf-8')): + raise ValueError('Mismatch: SUMMARY.json') + audit = call(scratch, 'audit.py').stdout + if audit != (root / 'AUDIT.json').read_bytes(): + raise ValueError('Byte mismatch: AUDIT.json') + previous = scratch / 'prior' + previous.mkdir() + for name in ('TYPED.json', 'GATE.json', 'typed_stock.py', 'decode_gate.py', 'audit.py'): + shutil.copyfile(scratch / name, previous / name) + exact_receipt(scratch, 'TWO-ARM.json', 'two_arm_gate.py', + ('--cap', '2602', '--seconds', '180')) + tensor_audit = call(scratch, 'audit_two_arm.py').stdout + if tensor_audit != (root / 'TWO-ARM-AUDIT.json').read_bytes(): + raise ValueError('Byte mismatch: TWO-ARM-AUDIT.json') + if args.controls: + controls(root, scratch, gate) + print('PASS_FINITE_MONOMIAL_ARM_STOCK moves=6281 pairs=2602 tensor_reject=1516 circular=1086 saving=0') + + +if __name__ == '__main__': + try: + main() + except (OSError, ValueError) as error: + sys.exit(str(error)) diff --git a/research/p104-finite-monomial-decoder-bound/two_arm_gate.py b/research/p104-finite-monomial-decoder-bound/two_arm_gate.py new file mode 100644 index 0000000000..96f57f8ea9 --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/two_arm_gate.py @@ -0,0 +1,236 @@ +"""Two returned monomials: width-one support and finite-arm tensor gate.""" +from collections import Counter +from fractions import Fraction as Q +from functools import cache +from hashlib import sha256 +from importlib.util import module_from_spec, spec_from_file_location +from pathlib import Path +from time import monotonic +import argparse +import json + + +PINS = { + 'prior/TYPED.json': '68202ba9326938cb0bf5abbabb893c3db01090a22acb6ba55afaef1dbae2bf9c', + 'prior/GATE.json': 'd047446188cd0bb93c5835a536560dc6509e8369e774c017e0f4a63c98cdc61d', + 'prior/typed_stock.py': '85564000a1a1a54f46af4e2c7091351f918886f7e0868343c9518f7ef9a518f3', + 'prior/decode_gate.py': 'dc0fcc441e6c64797168acea834f42e6ff7c46dee8afdc9ac59d5fd4239f491c', + 'contracts/PROOF.md': 'd9cc72480f7fd7d7cdcac3d8617b91c39d0630f5dc36a67fb6c2dbf81377bbc0', + 'contracts/SOURCES.json': 'ac7b4473035af648d6073e78b6c39675e706e8194b346bb55ed62a0adc81d593', + 'contracts/canonical-PROOF-REVIEW.md': '4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055', + 'contracts/pr7161-PROOF.md': 'acbebef2405e98ec83e3013342167aaa7c06540e491a346cd2ed53ee3359c5e5', +} + + +class TimeCap(Exception): + pass + + +def checked(root, key): + path = root / key + data = path.read_bytes() + if sha256(data).hexdigest() != PINS[key]: + raise ValueError(f'SHA-256 mismatch: {key}') + return path, data + + +def load(root, key): + path, _ = checked(root, key) + spec = spec_from_file_location(path.stem, path) + m = module_from_spec(spec) + spec.loader.exec_module(m) + return m + + +def hist(rows): + return Counter(r['rank'] for r in rows) + + +def controls(stock): + d = stock.binary_span([1]) + e = stock.binary_span([1, 2]) + q = len(stock.binary_span(d + e)) - len(d) + assert q == 1 and 2 ** (q * 2) > 2 + 1 + # Multiplicity 3, two independent returned rows, one raw source row. + coherence_squared = Q(1, 8) + off_block_norm_bound = Q(1, 2) + assert off_block_norm_bound ** 2 == 2 * coherence_squared + gram_min = 1 - off_block_norm_bound + projection = 3 * coherence_squared / gram_min + assert projection == Q(3, 4) < 1 + assert len({3, 3}) == 1 + return dict(width_one_known_pass_and_tensor_fiber_failure=True, + distinct_basis_squared_coherence_upper=str(coherence_squared), + three_arm_gram_eigenvalue_lower=str(gram_min), + target_projection_squared_upper=str(projection), duplicate_returned_row_deduplicates=True) + + +def run(root, cap, seconds): + started = monotonic() + + def time(): + if monotonic() - started >= seconds: + raise TimeCap + + old = json.loads(checked(root, 'prior/TYPED.json')[1]) + prior = json.loads(checked(root, 'prior/GATE.json')[1]) + canonical = checked(root, 'contracts/canonical-PROOF-REVIEW.md')[1].decode() + manifest = json.loads(checked(root, 'contracts/SOURCES.json')[1]) + proof = checked(root, 'contracts/PROOF.md')[1].decode() + old_proof = checked(root, 'contracts/pr7161-PROOF.md')[1].decode() + assert any(x['sha256'] == PINS['contracts/canonical-PROOF-REVIEW.md'] for x in manifest['files']) + assert 'T_U^(tensor f) z' in canonical and 'arbitrary full arrays at every f' in canonical + assert 'all-column native maps' in proof and 'at every positive column multiplicity' in old_proof + assert old['moves_pending'] == 0 and prior['pending_groups'] == 0 + typed = load(root, 'prior/typed_stock.py') + previous = load(root, 'prior/decode_gate.py') + stock = typed.load_stock(root) + price = stock.load(root / 'deps', stock.PRICE_PATH, stock.PRICE_SHA) + clifford = stock.load(root / 'deps', stock.CLIFFORD_PATH, stock.CLIFFORD_SHA) + word = typed.authenticated(root, 'inputs/native/WORD.json.gz') + typed.authenticated(root, 'inputs/native/RESULT.json') + typed.authenticated(root, 'inputs/caller/CALLER.json') + tables = [clifford.canonical_frame(9, tuple(frame)).tab for frame in word['frames']] + inv = list(map(clifford.inverse, tables)) + cosets = [stock.binary_span(x | (z << 9) for x, z, _ in t[9:]) for t in inv] + + @cache + def direction(f, g): + relative = clifford.compose(tables[f], inv[g]) + return stock.binary_span(x for x, _, _ in relative[9:]) + + def moment(h): + return price.moment(h, price.TARGET) + + base = Q(old['baseline'][1]) + stages = old['stages'] + groups = old['eligible_group_details'] + total = sum(len(g['members']) * (len(g['members']) - 1) for g in groups) + assert total == 2602 and len(groups) == 898 + pending = Counter({int(k): n for k, n in old['skipped_child_hist'].items()}) + modes = ('width_one_clock_free', 'width_one_independent', 'tensor_finite_arms_independent') + saved = {mode: Counter() for mode in modes} + best = {mode: Counter() for mode in modes} + stats = Counter() + survivor_rows = {mode: [] for mode in modes[1:]} + disjoint = set() + tested = completed = 0 + reason = 'ordered-pair scope exhausted' + checkpoints = [] + + def bill(credit): + stage = moment(credit + pending) + return dict(savings_hist=dict(credit), stage_upper=str(stage[1]), + caller_upper=str(stages * stage[1]), raw_margin_upper=str(base + stages * stage[1])) + + def record(): + p = {mode: bill(saved[mode])['raw_margin_upper'] for mode in modes} + checkpoints.append(dict(groups=completed, pairs=tested, margins=p)) + return Q(p[modes[1]]) < 0 + + try: + first = previous.first_observation(word, groups, cosets, stock, time) + for group in groups: + time() + rows = group['members'] + case_count = len(rows) * (len(rows) - 1) + if tested + case_count > cap: + reason = 'ordered-pair cap' + break + key = tuple(map(tuple, group['projective_row'])) + ids = {e['event'] for e in rows} + assert len(ids) == len(rows) and not (ids & disjoint) + disjoint.update(ids) + assert len({cosets[e['target']] for e in rows}) == len(rows) + choices = {mode: [] for mode in modes} + for kept in rows: + f, g = kept['source'], kept['target'] + d = direction(f, g) + assert len(d) == kept['rank'] > 0 + residents = first[cosets[f], key] + matched = {mode: [] for mode in modes} + for removed in rows: + if kept is removed: + continue + tested += 1 + h = removed['target'] + e = direction(f, h) + between = direction(g, h) + assert bool(e) == (cosets[f] != cosets[h]) + assert bool(between) == (cosets[g] != cosets[h]) + quotient_dim = len(stock.binary_span(d + e)) - len(d) + stats['width_one_direction_pass' if quotient_dim <= 1 else 'width_one_direction_fail'] += 1 + if not between: + stats['identical_target_coset'] += 1 + elif not e: + stats['source_monomial_bypass'] += 1 + else: + stats['three_distinct_tensor_rejected'] += 1 + if quotient_dim > 1: + continue + matched[modes[0]].append(removed) + born = min((x for j, x in residents.items() + if j != removed['role'] or x[0] <= removed['event']), default=None) + if born is None or born[0] > removed['latest_clock']: + if not e: + stats['source_bypass_unavailable'] += 1 + continue + stats['width_one_independent_pass'] += 1 + note = dict(kept=kept['event'], omitted=removed['event'], omitted_rank=removed['rank'], + relative_ranks=(len(d), len(e), len(between)), quotient_dimension=quotient_dim, + source_observation=list(born), deadline=removed['latest_clock']) + matched[modes[1]].append(removed) + survivor_rows[modes[1]].append(note) + if not e or not between: + stats['tensor_independent_pass'] += 1 + matched[modes[2]].append(removed) + survivor_rows[modes[2]].append(note) + for mode in modes: + choices[mode].append(matched[mode]) + ideal_keep = group['retained_event'] + pending.subtract(hist(x for x in rows if x['event'] != ideal_keep)) + assert min(pending.values(), default=0) >= 0 + for mode in modes: + one = max(choices[mode], key=lambda r: moment(hist(r))[1]) + best[mode].update(hist(one)) + may_omit = {e['event'] for subset in choices[mode] for e in subset} + union = [e for e in rows if e['event'] in may_omit] + if len(union) == len(rows): + union.remove(min(union, key=lambda e: (e['rank'], e['event']))) + saved[mode].update(hist(union)) + completed += 1 + if completed % 32 == 0 and record(): + reason = 'negative width-one directed upper' + break + except TimeCap: + reason = 'time cap' + if not checkpoints or checkpoints[-1]['groups'] != completed: + record() + width = bill(saved[modes[1]]) + tensor = bill(saved[modes[2]]) + if completed == len(groups): + assert stats['source_monomial_bypass'] == prior['passed_by_mode']['support_no_clock'] + assert stats['source_bypass_unavailable'] == stats['source_monomial_bypass'] + return dict(status='NEGATIVE_FIXED_FINITE_MONOMIAL_ARMS' if Q(tensor['raw_margin_upper']) < 0 + else 'UNRESOLVED_OR_POSITIVE_TENSOR_UPPER', + head=old['source_head'], tree=old['source_tree'], target=old['target'], stages=stages, + source_pins={**PINS, **typed.PINS}, scope='One exact arbitrary projective lane and one retained old child. ' + 'The width-one screen grants two returned monomial arms, and the coherence proof applies to any ' + 'fixed finite source/returned arm count under the exact tensor lift.', + cap=dict(pairs=cap, seconds=seconds), tested_pairs=tested, pending_pairs=total-tested, + checked_groups=completed, pending_groups=len(groups)-completed, stop_reason=reason, + pending_ideal_hist={r: n for r, n in pending.items() if n}, stats=dict(stats), + old_baseline_upper=str(base), width_one_independent=width, tensor_independent=tensor, + union_prices={mode: bill(saved[mode]) for mode in modes}, + single_retained_prices={mode: bill(best[mode]) for mode in modes}, + checkpoints=checkpoints, survivors=survivor_rows, controls=controls(stock), + site_tests=0, ordinary_costs_granted_free=True) + + +if __name__ == '__main__': + assert __debug__ + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('root', type=Path) + p.add_argument('--cap', type=int, choices=range(1, 2603), default=2602) + p.add_argument('--seconds', type=int, choices=range(1, 181), default=180) + print(json.dumps(run(**vars(p.parse_args())), indent=2, sort_keys=True)) diff --git a/research/p104-finite-monomial-decoder-bound/typed_stock.py b/research/p104-finite-monomial-decoder-bound/typed_stock.py new file mode 100644 index 0000000000..fcd147447c --- /dev/null +++ b/research/p104-finite-monomial-decoder-bound/typed_stock.py @@ -0,0 +1,161 @@ +"""Exact one-input multi-output MOVE stock by proportional rows and target cosets.""" +from collections import Counter, defaultdict +from fractions import Fraction as Q +from hashlib import sha256 +from importlib.util import module_from_spec, spec_from_file_location +from pathlib import Path +import argparse +import gzip +import json + + +HEAD = '4156504fa39efb51c550d218a9b94fe69dbce8f6' +TREE = 'f201bc8b5d1402ca40e7aa419269a58b7724798d' +PINS = { + 'inputs/native/WORD.json.gz': '75061d1e4b354e4cf36b690f30ddb2b257ed2f4e86509f87e17bb0f63eca126f', + 'inputs/native/RESULT.json': '75f34132b5b12b1a92f13b7a7c47ea3857f1955403090ae06b38dd9cf18aeb49', + 'inputs/caller/CALLER.json': '255d89f38cd45e38e5770f559bc43dc217e989032359768cdc7e8cdfd64b47bc', + 'deps/round20/complex-stock/stock.py': '8a1968502614a3c2fe90699460e9d7f8d4667fa9072b2947c53f430a0efab49e', + 'deps/round13/alternative/reprice.py': '97f4524d11a08cd3a09ceb9abc6b90f45ca579ac1c529a176b80a67201ecd90a', + 'deps/canonical/research/shared-wire-split-composition/frozen/clifford_exact.py': '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962', +} + + +def checked(root, key): + path = root / key + raw = path.read_bytes() + if sha256(raw).hexdigest() != PINS[key]: + raise ValueError(f'SHA-256 mismatch: {key}') + return path, raw + + +def authenticated(root, name): + path, data = checked(root, name) + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def load_stock(root): + path, _ = checked(root, 'deps/round20/complex-stock/stock.py') + spec = spec_from_file_location(path.stem, path) + stock = module_from_spec(spec) + spec.loader.exec_module(stock) + return stock + + +def invoice(word, caller, result, spaces, ranks): + main = set(word['live']) | {112 + r for r in word['live']} | set(word['hosted']['X2']) | set(word['hosted']['Y2']) + assert len(main) == 400 and len(word['initial']) == len(word['final']) == word['public'] == 1501 + assert sorted(p for spec in caller['types'].values() for p in spec['ports']) == list(range(104)) + assert sorted(word['hosted']['Dports']) == sorted(caller['types']['A']['ports']) + stages = [row[1] for row in caller['events'] if row[0] == 'J'] + assert stages == list(range(1, 18)) + repeat = len(stages) + native = Counter(abs(ranks[f] - ranks[g]) for op, _, *a in word['program'] if op == 'MOVE' for f, g, _ in (a,)) + targets = Counter() + for j, (f, g) in enumerate(zip(word['initial'], word['final'], strict=True)): + if j not in main: + assert spaces[f] < spaces[g] + targets[ranks[g] - ranks[f]] += repeat + for spec in caller['types'].values(): + for sign, h, *body in spec['diagonal']: + assert sign == -1 and h == 0 and len(body) == repeat and set(body) <= {0, 1} + targets[1 + 8 * sum(body)] += len(spec['ports']) + paid = Counter({r: n * repeat for r, n in native.items()}) + for row in caller['events']: + if row[0] == 'J': + continue + k, op, _, *a = row + p = len(caller['types'][k]['ports']) + if op == 'QUERY': + paid[1] += p + elif op in ('IDLE_ONE', 'IDLE_ODD'): + paid[8 * len(a[0]) + (op == 'IDLE_ODD')] += p + frozen = result['price']['after'] + physical = result['checks']['ODD-PHYSICAL-BINDING.json']['occurrence_and_geometry'] + for hist, field, physical_field in ((paid, 'P', 'paid'), (targets, 'T', 'targets')): + assert {str(r): n for r, n in hist.items()} == frozen[field] == physical[physical_field] + assert sum(native.values()) == 6281 and sum(paid.values()) == 110553 and sum(targets.values()) == 22461 + assert sum(r * (targets[r] - paid[r]) for r in targets.keys() | paid.keys()) == frozen['S'] == 1424 + assert result['caller_sha256'] == PINS['inputs/caller/CALLER.json'] + return targets, paid, native, repeat + + +def controls(stock): + assert stock.proportional({1: Q(1), 3: Q(2)}) == stock.proportional({1: Q(-3), 3: Q(-6)}) + assert stock.proportional({1: Q(1), 3: Q(2)}) != stock.proportional({1: Q(1), 3: Q(3)}) + groups = [[{'rank': 3, 'event': 0}, {'rank': 1, 'event': 3}], [{'rank': 2, 'event': 4}]] + assert [min(group, key=lambda r: (r['rank'], r['event']))['event'] for group in groups] == [3, 4] + return dict(signed_proportional=True, one_coefficient_corruption_splits_group=True, + cheapest_retained_charged=True) + + +def run(root, cap, seconds): + assert __debug__ + w, frozen, caller = (authenticated(root, key) for key in list(PINS)[:3]) + stock = load_stock(root) + price = stock.load(root / 'deps', stock.PRICE_PATH, stock.PRICE_SHA) + clifford = stock.load(root / 'deps', stock.CLIFFORD_PATH, stock.CLIFFORD_SHA) + ranks = list(map(len, w['frames'])) + spaces = [price.span(basis) for basis in w['frames']] + targets, paid, native, stages = invoice(w, caller, frozen, spaces, ranks) + rows, _, reason = stock.sweep(w, spaces, ranks, cap, seconds) + tables = [clifford.canonical_frame(9, tuple(frame)).tab for frame in w['frames']] + inverse = list(map(clifford.inverse, tables)) + cosets = [stock.binary_span(x | (z << 9) for x, z, _ in inv[9:]) for inv in inverse] + groups = defaultdict(list) + zero = [] + for row in rows: + if row['row']: + groups[stock.proportional(row['row'])].append(row) + else: + zero.append(row) + assert sum(map(len, groups.values())) + len(zero) == len(rows) + eligible = [] + saving = Counter() + added = stock.hist(zero) + member_ids = set() + for coeff, group in groups.items(): + kinds = {cosets[row['target']] for row in group} + if len(kinds) < 2: + continue + keep = min(group, key=lambda row: (row['rank'], row['event'])) + dropped = [row for row in group if row is not keep] + saving.update(stock.hist(dropped)) + assert not member_ids.intersection(row['event'] for row in group) + member_ids.update(row['event'] for row in group) + eligible.append(dict(projective_row=coeff, target_cosets=len(kinds), + retained_event=keep['event'], retained_rank=keep['rank'], + members=[{k: v for k, v in row.items() if k != 'row'} for row in group])) + old = targets.copy() + old.subtract(paid) + before = price.moment(old) + pending = native.copy() + pending.subtract(stock.hist(rows)) + assert all(n >= 0 for n in pending.values()) + grant = saving + added + pending + stage = price.moment(grant) + over_all = tuple(stages * q for q in stage) + upper = before[1] + over_all[1] + return dict(status='NEGATIVE_TYPED_STOCK_UPPER' if upper < 0 else 'POSITIVE_OPTIMISTIC_STOCK', + scope='One retained original child per exact proportional row group and distinct target cosets; free typed outputs.', + cap=dict(moves=cap, seconds=seconds), stop_reason=reason, source_head=HEAD, source_tree=TREE, + input_pins=PINS, target=str(price.TARGET), stages=stages, moves_checked=len(rows), + moves_pending=sum(pending.values()), original_paid_positions=sum(paid.values()), + original_productive_targets=sum(targets.values()), + row_groups=len(groups), nonzero_repeated_groups=sum(len(g)>1 for g in groups.values()), + repeated_same_target_only_groups=sum(len(g)>1 and len({cosets[x['target']] for x in g})==1 for g in groups.values()), + eligible_groups=len(eligible), eligible_members=len(member_ids), target_cosets=len({cosets[row['target']] for row in rows}), + eligible_member_hist=dict(Counter(len(g['members']) for g in eligible)), + eligible_group_details=eligible, zero_row_events=[r['event'] for r in zero], + retained_hist=dict(Counter(g['retained_rank'] for g in eligible)), + skipped_child_hist=dict(saving), pending_full_credit_hist={r: n for r, n in pending.items() if n}, + per_stage_saving_interval=list(map(str, stage)), complete_saving_interval=list(map(str, over_all)), + baseline=list(map(str, before)), raw_margin_upper=str(upper), controls=controls(stock), site_tests=0) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('root', type=Path) + parser.add_argument('--cap', type=int, choices=range(1, 6282), default=6281) + parser.add_argument('--seconds', type=int, choices=range(1, 481), default=480) + print(json.dumps(run(**vars(parser.parse_args())), indent=2, sort_keys=True))