From 4f808a69e12e4a61a4a601ea80b195effdef0a52 Mon Sep 17 00:00:00 2001 From: franciscoyne001-svg <271460452+franciscoyne001-svg@users.noreply.github.com> Date: Tue, 13 Oct 2026 10:42:10 -0400 Subject: [PATCH 1/2] Document finite R420 helper and shared-donor construction Contributed by franciscoyne001-svg with substantial OpenAI Codex assistance. Preserve predecessor attribution; no new kappa claimed. --- .../r420-two-sided-compensation/README.md | 162 ++++++++++++++++++ 1 file changed, 162 insertions(+) create mode 100644 research/r420-two-sided-compensation/README.md diff --git a/research/r420-two-sided-compensation/README.md b/research/r420-two-sided-compensation/README.md new file mode 100644 index 0000000000..e9e99fdd4c --- /dev/null +++ b/research/r420-two-sided-compensation/README.md @@ -0,0 +1,162 @@ +# Two-sided R420 dirt compensation with shared donors: 8,412 fewer XORs + +**Finite circuit construction; no new kappa.** This package replaces only the +frame-zero D compensation in eumemic's historical PR543 R420 bit supplier. +Combining 202 disjoint helper transvections with 68 target transvections +using 47 shared donors reduces D from **19,922 to 11,510 binary ADDs**, and +the complete native word from **26,916 to 18,504** (8,412 fewer, about 31.3%). Preparation +and restoration of both bases are included. Every arbitrary helper and target +input is accounted for. + +The helper-only pass costs 12,988 ADDs; factoring target rows **after** that +pass saves another 1,478. This is a concrete combined recipe extending the +credited one-sided mechanisms, not a priority claim for basis factoring. +Our 202 helper pairs differ from PR694's 201-pair matching, despite equal +helper-only cost. For the frozen donor set, each receiver is assigned its best positive-gain donor. +No optimality of the donor set or whole circuit is claimed. + +## Reproduce + +From the repository root, with Python 3.9+ and the standard library: + +```sh +python3 -B research/r420-two-sided-compensation/verify.py +``` + +Expected final line: + +```text +PASS_R420_TWO_SIDED D=19922->11510 native_ADDs=26916->18504 saved=8412 columns=660 no_new_kappa +``` + +The default run uses a temporary directory. Add `--output /path/to/fresh/output` +to keep the reconstructed candidate, independent report, native records and +execution receipts. Source files and frozen certificates are not regenerated +by the default command. `construct.py` reproduces the seed-3 nomination; +`--write-certificate` explicitly refreshes only this package's certificate. +An available C++ compiler and Boost headers enable the optional unchanged +native C++ checks automatically; otherwise their non-execution is reported. + +## Evidence and cost + +`CERTIFICATE.json` is compared against a fresh exact recomputation. The main +verifier uses the pinned original E8 label/frame checker, 660 arbitrary-input +columns, the original suffix interface and a semantic D endpoint check. +`audit_independent.py` imports neither producer nor primary verifier; it uses +sets to reconstruct the matrix substitution and independently replays D and +the full word. Corruptions include missing helper restoration, missing target +preparation, missing target restoration, incorrect feed, changed retained +totals and illegal frames. The independent checker rejects a receiver reused +as a donor. A missing serialized D ADD passes legality but fails the physical +column checks. An F2-neutral pair is required to pay both ADDs. + +`native.py` invokes the unchanged record exporter and checks the actual +serialized records. The entire 2,958-record MOVE/COPY/ERASE subsequence and +the frame/state files are identical. Helpers remain 420, copies remain nine, +and the paid histogram is `{1:1320,2:1440,4:60,5:120,8:9}`, with rank mass +5,112. Total native records fall from 29,874 to 21,462. + +| Exact local quantity | Original | Two-sided | +|---|---:|---:| +| Forward positive-prefix bound | 144,651 | 203,415 | +| Reverse positive-prefix bound | 2,270,064 | 4,284,358 | +| Local payload bit length | 100 | 103 | + +The recalculated payload is `64 * 203415^3 * 4284358^2 = +9887816668588668030197998944000 < 2^104`. Thus the local cap passes despite +larger integer envelopes. This does not justify reusing a global hosted invoice. + +Python replay of the exported 5/9/11-stage schedules covers 900/1,380/1,620 +physical columns and the respective 6/18/24 bridge-omission controls for both +words. Its schedule and prefix formula are ports of the pinned upstream +`columns_k.cpp`; they are **not** an independent proof of that composition +theorem. Fresh unchanged C++ legality and 5/9/11-stage checks also passed for both +words using Apple Clang 21.0.0 and authenticated Boost 1.85.0 headers. Their +receipts and dependency checksum are retained in `VALIDATION.json` and +`NATIVE-CPP.json`. The default standard-library run can report C++ unavailable +when Boost is not configured; use `BOOST_INCLUDE=/path/to/boost_1_85_0` to +repeat those checks. No remote CI, full `make verify`, selected frontier cold +replay, Lean theorem, or hosted-parent replay is claimed. + +## Interface and remaining work + +The original syntactic H2 and literal K extractor reject the replacement, +as expected. They are left unchanged. [PROOF.md](PROOF.md) states the precise +semantic replacement: D runs first at frame zero and realizes exactly +`(x,s,y) -> (x,s,y+Ks)`, restoring all helpers. Every non-D field is fixed. +The proof uses `M=T K H`, prepares both involutive bases, feeds M, then +restores both bases; the independent checker reconstructs these products. + +Integration still requires review of that semantic interface, full +hosted-parent construction and whole-owner routing, revised global invoices, +and changed-word outer assembly. All inherited all-size compiler, +common-label/mutable-basis, pooled-cell hosting, residual, precision/tape and +analytic assumptions remain. Fewer finite XORs do not establish a practical +runtime gain or an improved asymptotic exponent. This package makes no change +to the selected frontier; its baseline is the historical PR543 word, not the +current selected bit supplier. + +## Search, source pins and overlap + +Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +PR543 source: `2065fe4f72a914d907f1046603f5a36f17018535`. +Historical selected PR626 source: `660de893d27bb7abd1d5b01b1640207528a5c851`. +`SOURCES.json` binds the consumed sources; the compressed input is pinned by +canonical JSON payload, allowing equivalent gzip containers. The historical +selected-result hash is provenance only, not a dependency of this finite check. + +OS assignment seed **3**, bit-supplier track. The bounded search scores all +175,980 oriented helper pairs, performs one seed-3 greedy disjoint selection, +then scores all 14,280 oriented target pairs on the transformed matrix and +performs one greedy selection. After concurrent PR733 appeared, one extension +allowed shared target donors. The initial 56 donors from the matching undergo +at most 30 strictly improving single-donor add/remove iterations. There are +15 successful iterations followed by a no-improvement stop (1,920 candidate +donor sets evaluated), leaving 47 donors and 68 receivers. For each donor set, +all eligible receiver/donor pairs are scored exactly, paying two basis gates +per receiver. A preliminary 16-donor greedy trial was worse and discarded; +CLAIM.json preserves its result. The search does not cover all donor sets, +matchings, or orderings. No further search followed the stated stop. + +The complete open-PR and issue inventory was initially checked through PR730; +a refresh reached PR748 and triggered the recorded single scope extension. The only +open non-PR issue was #650 (Discussions), so the sprint claim is local in +`CLAIM.json`. Relevant concurrent work: #686 and #694 factor helper columns; +#713 and #716 factor target rows; #708 factors separate decoder totals; +#710 changes cleanup. None of their code or frozen circuits is imported. +Concurrent #733 combines helper and disjoint target bases, saving 8,368 ADDs; +#742 permits shared target donors with helpers held fixed. Both are credited. +This package combines the two mechanisms, saving 83 beyond our own disjoint +construction and 44 more than #733 on the same PR543 baseline. The helper +bases differ, so 44 is a total-count comparison, not a patch to #733. +No priority is claimed for two-sided factoring or shared donors. The added +evidence is the explicit combined donor circuit and its exact accounting. +A bounded pre-submission refresh on 2026-10-13 inspected the 200 most recent +open PRs through #946 and complete indexed R420-title, donor and two-sided +searches. No identical recipe surfaced; this is not an exhaustive novelty +guarantee. [PR817](https://github.com/CrocSwap/integer-mult-bounds/pull/817) +(`3147cac35c659152d36db1e0e60b9ce4b152c008`) certifies a different fixed helper +basis with disjoint target matching at D=11,546, versus 11,510 here. Its whole +word count includes separate PR681 changes and is not directly comparable. +[PR794](https://github.com/CrocSwap/integer-mult-bounds/pull/794) supplies a +192-bit hosted invoice for a different target construction; this package does +not supply that invoice. Later R439 constructions concern a different word. +`HANDOFF.md` summarizes review and integration obligations. + +## Attribution and license + +Apache-2.0, as in the repository. Contributed by +**[franciscoyne001-svg](https://github.com/franciscoyne001-svg)** with substantial +**OpenAI Codex assistance** in construction, proof, checking and packaging, +including separately instructed automated verification workers. No independent +human review is claimed. + +Credit to eumemic (PR543/493), Mikhail R. Gadelha (#686), Greer Guthrie (#694), +Scott Woolsey Biggart (#713/#733), Sagar Thakrar (#716/#817), ellipsi2 (#742), +and their predecessors. +The original format/exporter is Dylan Crow's; retain Zhihao Chen's scalar +interface, DreamingOfClouds' totals/pricing and the realization/hosting work +of Chafik Boukhalfa, DaysSky and the full lineage in +[the original notice](../e8-bit-r420/NOTICE.md). Native schedule/prefix code +credits Dylan Crow and DaysSky through the upstream checker. The mathematical +proof gives direct links to the concurrent mechanisms. From 49868be647e52c11a4e305a10d4cedb915a7cf3d Mon Sep 17 00:00:00 2001 From: franciscoyne001-svg <271460452+franciscoyne001-svg@users.noreply.github.com> Date: Tue, 13 Oct 2026 10:55:58 -0400 Subject: [PATCH 2/2] Add reproducible R420 circuit, proof and verification receipts Contributed by franciscoyne001-svg with substantial OpenAI Codex assistance. Exact finite checks save 8,412 ADDs relative to historical PR543; no new kappa. Source pins, independent audit, negative controls and native C++ receipts included. --- .../r420-two-sided-compensation/.gitignore | 2 + .../CERTIFICATE.json | 612 + .../r420-two-sided-compensation/CLAIM.json | 62 + .../r420-two-sided-compensation/HANDOFF.md | 51 + .../NATIVE-CPP.json | 1194 ++ research/r420-two-sided-compensation/PROOF.md | 326 + .../r420-two-sided-compensation/SOURCES.json | 25 + .../VALIDATION.json | 56 + .../audit_independent.py | 358 + .../r420-two-sided-compensation/construct.py | 116 + .../independent-audit.json | 175 + .../r420-two-sided-compensation/native.py | 409 + .../r420-two-sided-compensation/recipe.json | 12426 ++++++++++++++++ .../r420-two-sided-compensation/verify.py | 160 + 14 files changed, 15972 insertions(+) create mode 100644 research/r420-two-sided-compensation/.gitignore create mode 100644 research/r420-two-sided-compensation/CERTIFICATE.json create mode 100644 research/r420-two-sided-compensation/CLAIM.json create mode 100644 research/r420-two-sided-compensation/HANDOFF.md create mode 100644 research/r420-two-sided-compensation/NATIVE-CPP.json create mode 100644 research/r420-two-sided-compensation/PROOF.md create mode 100644 research/r420-two-sided-compensation/SOURCES.json create mode 100644 research/r420-two-sided-compensation/VALIDATION.json create mode 100644 research/r420-two-sided-compensation/audit_independent.py create mode 100644 research/r420-two-sided-compensation/construct.py create mode 100644 research/r420-two-sided-compensation/independent-audit.json create mode 100644 research/r420-two-sided-compensation/native.py create mode 100644 research/r420-two-sided-compensation/recipe.json create mode 100644 research/r420-two-sided-compensation/verify.py diff --git a/research/r420-two-sided-compensation/.gitignore b/research/r420-two-sided-compensation/.gitignore new file mode 100644 index 0000000000..fd6aad7fa7 --- /dev/null +++ b/research/r420-two-sided-compensation/.gitignore @@ -0,0 +1,2 @@ +output/ +__pycache__/ diff --git a/research/r420-two-sided-compensation/CERTIFICATE.json b/research/r420-two-sided-compensation/CERTIFICATE.json new file mode 100644 index 0000000000..ef388f9939 --- /dev/null +++ b/research/r420-two-sided-compensation/CERTIFICATE.json @@ -0,0 +1,612 @@ +{ + "status": "PASS_FINITE_TWO_SIDED_D", + "columns": 660, + "labels": { + "labels": 120, + "lattice_rank": 8, + "gram_det": 1, + "frames": 672 + }, + "baseline_word_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2", + "candidate_word_sha256": "e7579a429513090e904256bcf3d3b010df98345ce2d9ba6b2814391de990739c", + "recipe_sha256": "6a17478744c67583dba863d5ca3ae180363f15c1ba675e98a8e8c54fe861be40", + "helper_pairs": 202, + "target_pairs": 68, + "baseline_D_adds": 19922, + "helper_only_D_adds": 12988, + "candidate_D_adds": 11510, + "baseline_native_adds": 26916, + "candidate_native_adds": 18504, + "saved_adds": 8412, + "negative_controls": [ + "missing_helper_restoration", + "missing_target_preparation", + "missing_target_restoration", + "missing_feed_term", + "unpaid_nonzero_frame", + "changed_retained_total", + "corrupt_transformed_matrix", + "underpriced_neutral_pair" + ], + "unchanged_interface": [ + "H1_no_target_feeds_z", + "H3_A_z_only_scatter_targets_B_split", + "H4_C_literal_reverse_at_full", + "H5_V_identity" + ], + "original_syntax_rejections": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D" + ], + "scope": "Finite native circuit and semantic frame-zero D extension; no new kappa or hosted invoice", + "native": { + "baseline": { + "legality": { + "binary_ADDs": 26916, + "binary_ADDs_by_phase": { + "1": 19922, + "2": 2376, + "3": 568, + "4": 1077, + "5": 2973 + }, + "containment_pairs_checked": 2460, + "copies": 9, + "erasures": 9, + "moves": 2940, + "paid_histogram": { + "1": 1320, + "2": 1440, + "4": 60, + "5": 120, + "8": 9 + }, + "rank_mass": 5112, + "records": 29874, + "status": "PASS_PYTHON_NATIVE_RECORD_LEGALITY" + }, + "physical_columns": [ + { + "bridge_additions": 720, + "formal_columns_checked": 900, + "fresh_center_copies": 45, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "stages": 5, + "status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS" + }, + { + "bridge_additions": 2160, + "formal_columns_checked": 1380, + "fresh_center_copies": 81, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "stages": 9, + "status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS" + }, + { + "bridge_additions": 2880, + "formal_columns_checked": 1620, + "fresh_center_copies": 99, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "stages": 11, + "status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS" + } + ], + "prefix": { + "payload_prefix_bits": 100, + "payload_prefix_upper": "998206739997057013039187410944", + "payload_under_2_power_104": true, + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "144651", + "reverse": false + }, + { + "bits": 22, + "cancellation_free_signed_row_l1_upper": "2270064", + "reverse": true + } + ] + } + }, + "candidate": { + "legality": { + "binary_ADDs": 18504, + "binary_ADDs_by_phase": { + "1": 11510, + "2": 2376, + "3": 568, + "4": 1077, + "5": 2973 + }, + "containment_pairs_checked": 2460, + "copies": 9, + "erasures": 9, + "moves": 2940, + "paid_histogram": { + "1": 1320, + "2": 1440, + "4": 60, + "5": 120, + "8": 9 + }, + "rank_mass": 5112, + "records": 21462, + "status": "PASS_PYTHON_NATIVE_RECORD_LEGALITY" + }, + "physical_columns": [ + { + "bridge_additions": 720, + "formal_columns_checked": 900, + "fresh_center_copies": 45, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "stages": 5, + "status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS" + }, + { + "bridge_additions": 2160, + "formal_columns_checked": 1380, + "fresh_center_copies": 81, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "stages": 9, + "status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS" + }, + { + "bridge_additions": 2880, + "formal_columns_checked": 1620, + "fresh_center_copies": 99, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "stages": 11, + "status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS" + } + ], + "prefix": { + "payload_prefix_bits": 103, + "payload_prefix_upper": "9887816668588668030197998944000", + "payload_under_2_power_104": true, + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "203415", + "reverse": false + }, + { + "bits": 23, + "cancellation_free_signed_row_l1_upper": "4284358", + "reverse": true + } + ] + } + }, + "comparison": { + "binary_ADDs_saved": 8412, + "exact_MOVE_COPY_ERASE_paths_equal": true, + "frames_bytes_equal": true, + "non_ADD_records": 2958, + "non_ADD_stream_sha256": "16dfb2020b42ff95b5a523230de15f1aaf0f82b927bed82f2bb841578a909bef", + "paid_histogram_equal": true, + "paid_rank_mass_equal": true, + "states_bytes_equal": true + }, + "missing_D_negative_control": { + "legality_status": "PASS_PYTHON_NATIVE_RECORD_LEGALITY", + "native_all_column_rejections": [ + { + "reason": "local defining decoder on all physical columns", + "rejected": true, + "stages": 5 + }, + { + "reason": "local defining decoder on all physical columns", + "rejected": true, + "stages": 9 + }, + { + "reason": "local defining decoder on all physical columns", + "rejected": true, + "stages": 11 + } + ], + "record_index": 0, + "removed_record": [ + 1, + 552, + 521, + 1, + 0, + 1 + ], + "status": "PASS_MISSING_D_ADD_NEGATIVE_CONTROL" + } + } +} diff --git a/research/r420-two-sided-compensation/CLAIM.json b/research/r420-two-sided-compensation/CLAIM.json new file mode 100644 index 0000000000..001da9b8fb --- /dev/null +++ b/research/r420-two-sided-compensation/CLAIM.json @@ -0,0 +1,62 @@ +{ + "track": "bit supplier", + "assignment_seed": 3, + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "claim_time_utc": "2026-10-13T04:58:39.968651+00:00", + "object": "PR543 R420 D: disjoint helper basis plus shared target donors", + "method": "One seed-3 deterministic greedy helper-pair pass, then target-pair factoring of the transformed matrix; exact full arbitrary-input replay and prefix accounting. At most one alternate order if necessary.", + "candidates_considered": [ + "phase-B block 6 resynthesis (similar to #670/#674)", + "phase-A quad 3 resynthesis (similar to #691)", + "two-sided D basis factoring (chosen; extends separate #694 and #713/#716 mechanisms)" + ], + "deliverable": "Frozen finite circuit recipe, exact verifier, negative controls, proof and handoff; no new kappa", + "expected_finish_utc": "2026-10-13T05:25:00Z", + "coordination": "All 550 open issue entries checked: only non-PR issue650 (Discussions), no sprint coordination issue. Local claim retained; no GitHub claim was posted during the experiment.", + "overlap_context": { + "694": "9732ac127dd4bef98a846aaa904c20b5a84e72c1", + "713": "1a19af5c5ddb6de9797a6d085e5df0b90ed6d58b", + "716": "afeb452f58ff0cbf109172335e2ba282aac3dcde", + "733": "dfe84e09298abc5c5e0074afda59a821e10abfb4", + "742": "6e7a5d271a123886dc7b54ca3180d0b9f9beda5a", + "817": "3147cac35c659152d36db1e0e60b9ce4b152c008" + }, + "status": "verified finite construction; prepared for public pull request", + "pivot": { + "reason": "Final refresh found concurrent PR733 implementing two-sided disjoint bases, with 8368 saved ADDs. PR742 uses shared target donors without helper factoring.", + "time_utc": "2026-10-13T05:08:55.907316+00:00", + "scope": "Extend target basis to shared donors after fixed helper matching. Disjoint donor/receiver sets guarantee involution.", + "bounded_experiments": [ + { + "class": "original disjoint", + "D_adds": 11593 + }, + { + "class": "greedy 16 shared donors starting at target 3", + "D_adds": 11851, + "selected": false + }, + { + "class": "shared assignment to original matching donor set", + "D_adds": 11587 + }, + { + "class": "at most 30 strict single-donor toggles from that set;15 successful improvements then local stop", + "D_adds": 11510, + "selected": true + } + ] + }, + "initial_object": "PR543 R420 frame-zero D compensation; two-sided disjoint helper and target transvection bases", + "result": { + "D_adds": 11510, + "native_adds": 18504, + "saved_adds": 8412, + "payload_bits": 103, + "new_kappa": false, + "overlap_through_pr": 946 + }, + "contributor": "franciscoyne001-svg", + "assistance": "Substantial OpenAI Codex assistance in construction, proof, checking and packaging.", + "submission_overlap": "Bounded refresh: 200 recent open PRs through946 plus complete indexed R420-title, donor, two-sided and8412 searches. No identical recipe surfaced; no priority or exhaustive novelty claim. PR817 D11546 uses a different fixed helper basis and disjoint target matching; this D11510 uses shared donors. PR794 supplies a hosted invoice this package lacks." +} diff --git a/research/r420-two-sided-compensation/HANDOFF.md b/research/r420-two-sided-compensation/HANDOFF.md new file mode 100644 index 0000000000..155f16743c --- /dev/null +++ b/research/r420-two-sided-compensation/HANDOFF.md @@ -0,0 +1,51 @@ +# Handoff: R420 helper basis with shared target donors + +Status: **verified finite circuit construction**, contributed by +**franciscoyne001-svg** with substantial **OpenAI Codex assistance**. No new +kappa, selected-frontier edit, or full multiplication theorem is claimed. + +The complete PR543 R420 native word uses **18,504 instead of 26,916 XORs**, +saving **8,412**. D uses 11,510 additions, including 202 helper preparations, +68 target preparations, 10,970 feed terms and all 270 restorations. The 47 +target donors are disjoint from 68 receivers, so sharing donors is legal. +All 660 arbitrary-input columns pass, every helper is restored, and the +local payload bound is 103 bits below the 104-bit cap. + +Run from the repository root: + +```sh +python3 -B research/r420-two-sided-compensation/verify.py +``` + +Expected: + +```text +PASS_R420_TWO_SIDED D=19922->11510 native_ADDs=26916->18504 saved=8412 columns=660 no_new_kappa +``` + +Fresh unchanged C++ legality and 5/9/11-stage checks passed for the original +and changed words with authenticated Boost 1.85.0 headers. A missing-D +serialized mutation passes legality and fails all three C++ column checks. +The normalized receipts are in `NATIVE-CPP.json`; `VALIDATION.json` records +all completed and unrun checks. The default command also works without Boost. + +Historical experiment base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +Only `research/r420-two-sided-compensation/` is added. Source pins retain the +historical PR543 word and consumed checkers; selected-frontier changes are +independent of this finite construction. + +The bounded submission overlap refresh reached **PR946**. PR733 combines +helper and disjoint target bases (8,368 saved ADDs); PR742 provides shared +target donors with immutable helpers. This construction combines a helper +basis with shared target donors and includes a fixed-donor assignment proof. +It saves 83 beyond its original disjoint recipe, and 44 more than PR733 on +the historical PR543 baseline. PR817 has D=11,546 with a different helper +basis and disjoint targets, versus 11,510 here; its whole-word count also +includes separate PR681 changes. These are scoped comparisons, not priority +or best-known claims. No code or frozen recipe from those pending packages +is imported. See README.md for the overlap scope and attribution. + +Acceptance of the semantic D interface, complete hosted-parent/whole-owner +replay, global precision invoices and changed-word outer assembly remain +integration obligations. The original all-size, common-label/mutable-basis, +hosting, residual, precision/tape and analytic assumptions remain. diff --git a/research/r420-two-sided-compensation/NATIVE-CPP.json b/research/r420-two-sided-compensation/NATIVE-CPP.json new file mode 100644 index 0000000000..dfeb5b178b --- /dev/null +++ b/research/r420-two-sided-compensation/NATIVE-CPP.json @@ -0,0 +1,1194 @@ +{ + "baseline_canonical_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2", + "candidate_canonical_sha256": "e7579a429513090e904256bcf3d3b010df98345ce2d9ba6b2814391de990739c", + "exporter_sha256": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "official_cpp": { + "boost_headers_available": true, + "compiler_available": true, + "missing_D_negative_control": { + "legality_passed": true, + "native_all_column_rejections": [ + { + "reason": "local defining-decoder full formal column", + "rejected": true, + "returncode": 2, + "stages": 5 + }, + { + "reason": "local defining-decoder full formal column", + "rejected": true, + "returncode": 2, + "stages": 9 + }, + { + "reason": "local defining-decoder full formal column", + "rejected": true, + "returncode": 2, + "stages": 11 + } + ], + "record_index": 0, + "removed_record": [ + 1, + 552, + 521, + 1, + 0, + 1 + ], + "status": "PASS_CPP_MISSING_D_ADD_NEGATIVE_CONTROL" + }, + "python_receipt_comparison": { + "checks": [ + "legality counts", + "paid histogram and rank mass", + "binary ADD counts", + "exact forward and reverse prefix bounds", + "payload and bit lengths", + "5/9/11 column counts and omitted-bridge controls" + ], + "datasets": [ + "baseline", + "candidate" + ], + "status": "PASS_CPP_PYTHON_EXACT_RECEIPT_COMPARISON" + }, + "receipts": { + "baseline": { + "columns11": { + "bridge_additions": 2880, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1620, + "fresh_center_copies": 99, + "global_live_registers": 1620, + "independent_dirty_registers": 420, + "local_odd_scalar_additions": 26916, + "local_raw_H": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "local_registers": 660, + "local_scalar_additions": 26916, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 100, + "payload_prefix_upper": "998206739997057013039187410944", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "144651", + "reverse": false + }, + { + "bits": 22, + "cancellation_free_signed_row_l1_upper": "2270064", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 296076, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns5": { + "bridge_additions": 720, + "copied_center_original_source_immutable": true, + "five_stage_additions": 134580, + "formal_columns_checked": 900, + "fresh_center_copies": 45, + "global_live_registers": 900, + "independent_dirty_registers": 420, + "local_odd_scalar_additions": 26916, + "local_raw_H": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "local_registers": 660, + "local_scalar_additions": 26916, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 100, + "payload_prefix_upper": "998206739997057013039187410944", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "144651", + "reverse": false + }, + { + "bits": 22, + "cancellation_free_signed_row_l1_upper": "2270064", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns9": { + "bridge_additions": 2160, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1380, + "fresh_center_copies": 81, + "global_live_registers": 1380, + "independent_dirty_registers": 420, + "local_odd_scalar_additions": 26916, + "local_raw_H": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "local_registers": 660, + "local_scalar_additions": 26916, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 100, + "payload_prefix_upper": "998206739997057013039187410944", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "144651", + "reverse": false + }, + { + "bits": 22, + "cancellation_free_signed_row_l1_upper": "2270064", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 242244, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 26916, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 26916, + "containment_pairs_checked": 2460, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2940, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 671, + "paid_histogram": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "rank_mass": 5112, + "records": 29874, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + }, + "candidate": { + "columns11": { + "bridge_additions": 2880, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1620, + "fresh_center_copies": 99, + "global_live_registers": 1620, + "independent_dirty_registers": 420, + "local_odd_scalar_additions": 18504, + "local_raw_H": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "local_registers": 660, + "local_scalar_additions": 18504, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + }, + { + "omit_bridge": 18, + "rejected": true + }, + { + "omit_bridge": 19, + "rejected": true + }, + { + "omit_bridge": 20, + "rejected": true + }, + { + "omit_bridge": 21, + "rejected": true + }, + { + "omit_bridge": 22, + "rejected": true + }, + { + "omit_bridge": 23, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 103, + "payload_prefix_upper": "9887816668588668030197998944000", + "reverse_fresh_center_copies": 45, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "203415", + "reverse": false + }, + { + "bits": 23, + "cancellation_free_signed_row_l1_upper": "4284358", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 203544, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 8 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 9 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 10 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns5": { + "bridge_additions": 720, + "copied_center_original_source_immutable": true, + "five_stage_additions": 92520, + "formal_columns_checked": 900, + "fresh_center_copies": 45, + "global_live_registers": 900, + "independent_dirty_registers": 420, + "local_odd_scalar_additions": 18504, + "local_raw_H": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "local_registers": 660, + "local_scalar_additions": 18504, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 103, + "payload_prefix_upper": "9887816668588668030197998944000", + "reverse_fresh_center_copies": 18, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "203415", + "reverse": false + }, + { + "bits": 23, + "cancellation_free_signed_row_l1_upper": "4284358", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 4 + } + ], + "status": "PASS_NEW_COHORT249_ALL_FIVE_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "columns9": { + "bridge_additions": 2160, + "copied_center_original_source_immutable": true, + "formal_columns_checked": 1380, + "fresh_center_copies": 81, + "global_live_registers": 1380, + "independent_dirty_registers": 420, + "local_odd_scalar_additions": 18504, + "local_raw_H": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "local_registers": 660, + "local_scalar_additions": 18504, + "negative_controls": [ + { + "omit_bridge": 0, + "rejected": true + }, + { + "omit_bridge": 1, + "rejected": true + }, + { + "omit_bridge": 2, + "rejected": true + }, + { + "omit_bridge": 3, + "rejected": true + }, + { + "omit_bridge": 4, + "rejected": true + }, + { + "omit_bridge": 5, + "rejected": true + }, + { + "omit_bridge": 6, + "rejected": true + }, + { + "omit_bridge": 7, + "rejected": true + }, + { + "omit_bridge": 8, + "rejected": true + }, + { + "omit_bridge": 9, + "rejected": true + }, + { + "omit_bridge": 10, + "rejected": true + }, + { + "omit_bridge": 11, + "rejected": true + }, + { + "omit_bridge": 12, + "rejected": true + }, + { + "omit_bridge": 13, + "rejected": true + }, + { + "omit_bridge": 14, + "rejected": true + }, + { + "omit_bridge": 15, + "rejected": true + }, + { + "omit_bridge": 16, + "rejected": true + }, + { + "omit_bridge": 17, + "rejected": true + } + ], + "new_Q_categories": [ + 28, + 29 + ], + "payload_prefix_bits": 103, + "payload_prefix_upper": "9887816668588668030197998944000", + "reverse_fresh_center_copies": 36, + "scope": "All independent physical input columns over F2, including all arbitrary helper dirt, restored; external copied-center work closes to zero. New cohort scalar lift uses actual signed coefficients and computed cancellation-free bounds; unchanged source527 signed decoder remains separate defining evidence. Physical projector routing and paid rank/bank receipts are independently bound, not inferred from scalar check.", + "signed_lift_prefix": [ + { + "bits": 18, + "cancellation_free_signed_row_l1_upper": "203415", + "reverse": false + }, + { + "bits": 23, + "cancellation_free_signed_row_l1_upper": "4284358", + "reverse": true + } + ], + "signed_reverse_semantics": "Reverse ADD coefficient negated; reverse DISCARD is fresh COPY from recorded unchanged original center; reverse COPY is DISCARD. Each such block is inverse over every commutative coefficient ring, by elementary-shear induction.", + "stage_additions": 166536, + "stages": [ + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 0 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 1 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 2 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 3 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 4 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 5 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 6 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": true, + "stage": 7 + }, + { + "fresh_copies": 9, + "scalar_additions": 18504, + "signed_inverse": false, + "stage": 8 + } + ], + "status": "PASS_NEW_COHORT249_ALL_BRIDGED_STAGE_FORMAL_COLUMNS_AND_PREFIX_BILL" + }, + "legality": { + "all_final_frames_pass": true, + "common_frame_ADDs": 18504, + "containment_pairs_checked": 2460, + "copies": 9, + "donor_intersections": 0, + "erasures": 9, + "max_inherited_integer_abs": 2, + "nested_MOVEs": 2940, + "new_frame_ids_collision": false, + "nondegeneracy_checked_by_separate_exact_bank_audit": true, + "old_max_frame_id": 671, + "paid_histogram": [ + [ + 1, + 1320 + ], + [ + 2, + 1440 + ], + [ + 4, + 60 + ], + [ + 5, + 120 + ], + [ + 8, + 9 + ] + ], + "rank_mass": 5112, + "records": 21462, + "scope": "Independent chronological geometry/copy/source-owner audit. F2 all-column replay is in the separately freshly compiled transform receipt; address transform theorem and bank completion remain separate.", + "selected_helpers": 0, + "selected_pairs": 0, + "source_owner_intersections": 0, + "status": "PASS_INDEPENDENT_COHORT_LEGALITY_SOURCE_OWNERS_AND_LIFECYCLE" + } + } + }, + "status": "PASS_UNCHANGED_CPP_5_9_11_STAGE_CHECKERS" + }, + "status": "PASS_UNCHANGED_CPP_5_9_11_STAGE_CHECKERS", + "upstream_columns_k_sha256": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2" +} diff --git a/research/r420-two-sided-compensation/PROOF.md b/research/r420-two-sided-compensation/PROOF.md new file mode 100644 index 0000000000..6e839b3929 --- /dev/null +++ b/research/r420-two-sided-compensation/PROOF.md @@ -0,0 +1,326 @@ +# Restored helper matching and shared target donors for R420 compensation + +This is a proof of a finite circuit substitution over **F2**. It applies to the +pinned PR543 word in `../e8-bit-r420/data/bitE8mut-r420.json.gz`, at the base +commit recorded in `CLAIM.json`. It does not establish a new kappa, an optimal +circuit, an integer endpoint identity, or an all-size multiplication theorem. +The numerical receipt and the frozen recipe must be checked separately against +the emitted word; the argument below explains the exact identity they certify. + +## Interface and notation + +Write the initial state as `(x, s, y)`, with 120 source coordinates, 420 arbitrary +helper coordinates, and 120 arbitrary target coordinates. These are the native +register ranges `0:120`, `240:660`, and `120:240`, respectively. The order in +this mathematical tuple is not the order of the native register numbers. +Every helper and target starts at frame zero. The original D consists of 120 +grouped gates, containing 19,922 binary ADDs, and has the map + +``` +(x, s, y) -> (x, s, y + K s), K in F2^(120 x 420). +``` + +Here `K[t,j]` is the parity of occurrences of helper register `240+j` in +original D gates with target destination `120+t`. Counting parity rather than +presence is necessary for a general extractor. The pinned source has the +literal helper-to-target form, so its 19,922 binary ADDs equal `wt(K)`. +`wt` denotes the number of nonzero matrix entries, not a gate-record count. + +The semantic replacement for the original syntactic H2 condition is: + +1. D runs first, and each of its operands is a helper or target at frame zero. +2. D uses legal binary XORs with distinct source and destination registers. +3. Its complete operator is `(x,s,y) -> (x,s,y+Ks)` for arbitrary inputs. +4. Every field outside D is identical to the pinned source word. + +The original H2 demands only helper-to-target gates. The replacement contains +helper-to-helper and target-to-target gates and therefore needs this explicit +semantic interface. The original H2 predicate and its literal D extractor do +not become proofs for the replacement merely because the endpoints agree. +No alteration of a predecessor checker is justified by this argument. + +## Basis identity + +For distinct coordinates `a,b`, let `E_ab` be the matrix with a single one in +row `a`, column `b`. The instruction `s_a += s_b` applies +`I + E_ab`. Since `E_ab^2 = 0` and the characteristic is two, + +``` +(I + E_ab)^2 = I. +``` + +Choose `p` oriented helper pairs with disjoint endpoints and let `H` be the +product of their transvections. The factors commute and are involutions, so +`H^-1 = H`. No helper may appear in two helper pairs. + +For targets choose a donor set S and a receiver set R with `S intersect R` +empty. Each receiver a has exactly one assigned donor b in S, while the same +donor may serve several receivers. Let q be the number of receivers, set +`N = sum E_ab` over these assignments, and set `T = I + N`. For any two +selected terms, + +``` +E_ab E_cd = delta_(b,c) E_ad = 0, +``` + +because b is a donor and c is a receiver. Thus `N^2=0`; all these target +transvections commute; their product is `I+N`; and `T^2=I` over F2. A target +may occur as a donor many times, but no receiver may be used as a donor. +The helper and target transformations act on distinct register banks. + +Set `L = K H` and `M = T L = T K H`, with all products over F2. The replacement +executes these stages: + +1. Prepare helpers: `s' = H s`. +2. Prepare targets: `y' = T y`. +3. For each nonzero entry of M, add that prepared helper to that target: + `y'' = y' + M s'`. +4. Restore targets with the chosen target transvections in reverse order. +5. Restore helpers with the chosen helper transvections in reverse order. + +The two restoration stages may be exchanged because they have disjoint +register banks. In either order the final state is + +``` +s_final = H H s = s, +y_final = T (T y + (T K H)(H s)) = y + K s, +x_final = x. +``` + +Writing `H=I+Q` makes the required middle matrix explicit: + +``` +M = (I+N) K (I+Q) = K + KQ + NK + NKQ. +``` + +The mixed term `NKQ` cannot be omitted when combining the two sides. This is +also why target scores must be recomputed on KH. + +Thus this realizes the required D operator for **all** helper and target +inputs. Target preparation is essential: performing only the feed and target +restoration would give `T y + K s`, which can pass a test initialized with +`y=0` while failing the required arbitrary-input contract. Helper restoration +is independently essential to the state presented to phase A. + +All feed operations write a target and read only a helper. Their effects +commute, as no feed writes a source for any other feed. The proof therefore +permits their deterministic order in the frozen recipe. Preparation and +restoration are distinct paid operations even though each pair composes to +the identity when the feed is absent. + +## Exact scoring and paid cost + +An oriented helper operation `s_a += s_b` replaces **column b** of K by +`K_b + K_a`; column a is unchanged. Consequently its reduction in feed cost, +after paying its preparation and restoration, is + +``` +g_H(a,b) = wt(K_b) - wt(K_b + K_a) - 2. +``` + +This orientation matters. The coordinate changed in the helper state and the +column changed in the feed matrix are different. Disjoint pairs modify +different columns without changing the columns used by another pair, so the +helper gains add exactly. This gives + +``` +wt(K) - (wt(KH) + 2p) = sum g_H(a,b). +``` + +An oriented target operation `y_a += y_b` replaces **row a** of L by +`L_a + L_b`; row b is unchanged. Its paid gain is + +``` +g_T(a,b; L) = wt(L_a) - wt(L_a + L_b) - 2. +``` + +These gains remain additive with shared donors: each receiver row is changed +once, and every donor row remains unchanged. They must be scored on `L = KH`, +after helper factoring. Adding a target-only saving measured on K to a +helper-only saving measured on K would not establish the saving of the +combined construction. For the actual combined word, + +``` +D_ADDs = 2p + wt(TKH) + 2q, +saved = 19,922 - D_ADDs + = sum g_H(a,b) + sum g_T(a,b; KH). +``` + +Every grouped gate contributes one binary ADD per listed source. The complete +source word has 26,916 binary ADDs, of which 6,994 lie outside D, hence +`complete_ADDs = 6,994 + D_ADDs`. A strict finite improvement requires a +positive computed saving after all four basis passes are included. + +For the final frozen `recipe.json`, `p=202`, `q=68`, `wt(KH)=12,584`, and +`wt(TKH)=10,970`. There are 47 nominated donors, all of which are used, and +68 distinct receivers; the two sets are disjoint. Thus the helper-only cost +is `12,584+404=12,988`, and the final D cost is `10,970+404+136=11,510`. +This saves 8,412 ADDs relative to the source, including 1,478 beyond this +recipe's own helper-only pass. The full word has `6,994+11,510=18,504` ADDs. +These counts were independently checked by set-valued matrix updates and an +all-input D replay. They do not depend on assuming that the 202-pair helper +matching equals PR694's different, 201-pair matching with the same 12,988 +helper-only cost. + +## Fixed-donor assignment and bounded search + +Fix L and a nominated donor set S. The admissible target class in this +section has at most one donor per receiver, no receiver in S, no constraint +on donor reuse, and the two paid ADDs already included in each gain. For +each target a outside S, the best available contribution is + +``` +f_a(S) = max(0, max_(b in S) g_T(a,b; L)), +F(S) = sum_(a not in S) f_a(S). +``` + +For empty S take each `f_a(S)=0`. Every admissible assignment has a contribution +at most `f_a(S)` at receiver a. Conversely, choosing a maximizing donor for +each a with positive `f_a(S)` attains every term simultaneously: donor reuse +is allowed, receivers are distinct, and no receiver changes a donor. The +sum F(S) is therefore the exact best saving **for this fixed donor set and +this one-donor-per-receiver class**. The independently checked final value +is `F(S)=1,478`. + +The construction first uses the seed-3 greedy helper matching, followed by +the original greedy disjoint target matching on KH. Its 56 target donors +seed S. Allowing their reuse yields an initial fixed-donor optimum of 1,401 +saved ADDs beyond the helper-only word, compared with 1,395 for the original +disjoint target matching. The bounded refinement examines single-donor +additions and removals, chooses a strictly improving toggle, and recomputes +the fixed-donor best assignment. It allows at most 30 such improvement +iterations. The frozen trace contains the initial state and 15 strict +improvements, ending at 47 donors and saving 1,478. Thus the final circuit +saves 83 ADDs beyond the initial 8,329-saving disjoint construction. + +The fixed-S argument is a restricted optimality statement about assignments, +not about choosing S. Neither the greedy helper choice nor this bounded +donor refinement proves a global donor-set optimum, optimality among +two-sided bases, or optimality among arbitrary D circuits. Allowing more +than one donor at a receiver would change the admissible class and its cost +calculation. The construction makes no claim for that larger class. + +## Composition with the unchanged suffix + +The pinned PR543 scalar interface gives its raw `(A, scatter, B)` suffix the +form + +``` +(z, y) -> (U z, y + J x + K s), z = (x,s), J = I, +``` + +and its cleanup C restores z by applying `U^-1`. In particular, the raw +target-to-target operator is the identity. At the end of the replacement D, +the helpers equal their original arbitrary input, while the target input to +the suffix is `y+Ks`. The unchanged suffix therefore returns + +``` +(x, s, y + K s + x + K s) = (x, s, y+x) +``` + +over F2. This argument uses the pinned suffix's verified interface; it does +not infer correctness from a zero-helper or zero-target simulation. + +Since all 660 initial coordinates are independent and every operation is +linear, exact agreement on their 660 basis columns proves agreement for +every F2 input. A verifier should check the D operator itself and replay the +whole changed word. The direct matrix proof and the full replay have +different roles: the former explains the substitution, while the latter can +detect an incorrect extractor, orientation, recipe, or emitted instruction. +Reverse replay must also use the actual reversed word; involutivity of the +desired endpoint alone is not a check of the emitted reverse stream. + +## Frames, resources, and the conditional boundary + +Every inserted operation touches only helpers and targets before their first +climb. They all occupy the identical zero frame. No inserted operation +requires a MOVE, COPY, ERASE, new register, or nonzero-frame source support. +At the D boundary the helper contents and all register frames equal those +of the original D boundary. Fields outside D are unchanged, so the existing +frame paths, nine retained copies, 420 helpers, and local rank histogram are +preserved. The histogram is + +``` +{1:1320, 2:1440, 4:60, 5:120, 8:9}, +``` + +with rank mass `1*1320 + 2*1440 + 4*60 + 5*120 + 8*9 = 5,112`. +Literal stream comparison should confirm that its MOVE/COPY/ERASE subsequence +is unchanged. Merely retaining the same histogram would be weaker evidence. + +Extending this finite scalar substitution to the project's physical +realization still invokes the inherited common-label/mutable-basis interface: +an XOR of coordinates sharing a label must implement that XOR regardless of +the current meaning or role of those coordinates. Frame-zero helper mixing +and target mixing do not prove that all-size interface. This package does +not discharge the hosted-parent reconstruction, physical owner routing, +whole-owner invoice, precision/tape bounds, or changed-word outer assembly. + +## Positive integer prefix accounting is separate + +The cancellation `H^2 = T^2 = I` holds over F2. It does **not** mean that two +positive integer ADDs undo each other. For example, over integers the pair +`s_a += s_b; s_a += s_b` leaves `s_a + 2s_b`. It consumes two ADDs and can +increase a cancellation-free prefix bound despite being F2-neutral. + +The changed stream therefore needs fresh forward and reverse positive-prefix +calculations. In a native record replay initialize each live input bound to +one and scratch to zero; for an ADD of coefficient c use +`bound[dst] += abs(c)*bound[src]`, for COPY copy the appropriate bound, and +for ERASE reset scratch to zero. Record the maximum throughout the actual +chronological stream. Apply the same rule to the actual reversed stream, +including the reversed COPY/ERASE lifecycle. For the all-positive local +stream these are its exact cancellation-free row-sum bounds; taking absolute +values in a signed reverse stream gives the corresponding safe majorant. + +A lower XOR count, an unchanged endpoint matrix, or an unchanged movement +profile implies no reduction in this prefix quantity. A verifier must derive +any stated local payload allowance from the changed bounds and check its cap +afresh. Passing the inherited local 104-bit cap would be a local condition, +not permission to reuse a hosted global invoice. No signed integer endpoint +equality or preservation of the old positive-prefix bound is asserted here. + +The final changed-word native replay reports cancellation-free prefix bounds +203,415 forward and 4,284,358 reverse, and a local payload allowance of 103 +bits. These are changed-stream accounting results, separate from the F2 +basis identity; they remain below the 104-bit local cap without establishing +a revised hosted or global invoice. + +## Attribution and scope of the extension + +The underlying R420 word and its scalar-interface proof are eumemic's +[PR543](https://github.com/CrocSwap/integer-mult-bounds/pull/543), with its +cumulative predecessor lineage and conditional interfaces retained. +[PR686](https://github.com/CrocSwap/integer-mult-bounds/pull/686), by Mikhail R. +Gadelha, establishes restored one-pair helper factoring and the semantic D +contract; [PR694](https://github.com/CrocSwap/integer-mult-bounds/pull/694), by +Greer Guthrie, extends that helper mechanism to a disjoint matching. +[PR713](https://github.com/CrocSwap/integer-mult-bounds/pull/713), by Scott +Woolsey Biggart, supplies restored target-basis factoring; and +[PR716](https://github.com/CrocSwap/integer-mult-bounds/pull/716), by Sagar +Thakrar, supplies a stronger target-only matching with a certificate of +optimality restricted to that one-sided class. The reversible target-factoring +precedent [PR476](https://github.com/CrocSwap/integer-mult-bounds/pull/476) is +also credited through that lineage. + +[PR733](https://github.com/CrocSwap/integer-mult-bounds/pull/733), by Scott +Woolsey Biggart, already combines a restored helper matching with a restored +disjoint target matching on the transformed matrix. Its reviewed head is +`dfe84e09298abc5c5e0074afda59a821e10abfb4` and it reports 8,368 saved ADDs. +[PR742](https://github.com/CrocSwap/integer-mult-bounds/pull/742), by +`@ellipsi2`, permits shared target donors while leaving helpers unchanged; +its reviewed head is `6e7a5d271a123886dc7b54ca3180d0b9f9beda5a`. It also +provides the fixed-donor best-assignment argument. Both appeared in the +overlap evidence before finalization and are credited directly. + +The limited extension studied here is a frozen **helper matching plus shared +target donors** on KH, with target gains recomputed after the helper pass, +one bounded donor-set refinement, and every operation paid. Neither the +two-sided composition from PR733, shared-donor mechanism and fixed-donor +lemma from PR742, earlier one-sided mechanisms, reversible basis changes, +nor the semantic D contract is claimed as new. The 8,412 saved ADDs are 44 +more than PR733's reported 8,368, but its helper basis is different; that +comparison does not isolate a 44-ADD effect of shared donors on its circuit. +The controlled comparison on this package's own fixed helper basis is the +83-ADD reduction above. This proof establishes neither priority nor an +overall circuit record, and any later overlap remains a submission concern. diff --git a/research/r420-two-sided-compensation/SOURCES.json b/research/r420-two-sided-compensation/SOURCES.json new file mode 100644 index 0000000000..e94e859b8b --- /dev/null +++ b/research/r420-two-sided-compensation/SOURCES.json @@ -0,0 +1,25 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "PR543_source": "2065fe4f72a914d907f1046603f5a36f17018535", + "PR626_source": "660de893d27bb7abd1d5b01b1640207528a5c851", + "word_path": "research/e8-bit-r420/data/bitE8mut-r420.json.gz", + "word_canonical_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2", + "files_sha256": { + "research/e8-bit-r420/code/xcheck.py": "5737d18a7826fd51e131035f2d7bebba2e2868af91dd7672a5f11208b036d424", + "research/e8-bit-r420/README.md": "9807be57c6adf26b30e4f54e2f8160075bbc05091f1a6d157e43d2a4620c1c9f", + "research/e8-bit-r420/NOTICE.md": "12ba6e0845f222e9940b00f6c60d261db104246a8d3143da267682973479f811", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/bit/regression/stage_cohort.py": "6c288f6f234b528c1a7c0a4adfb724e91e0fe6b18c8dffad96af3f973de1829a", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_k.cpp": "1c344d18fcd494eeca93e259f10cafae7705780e6592f6dcb35b34752dab9bc2", + "research/e8-bit-carrier-skeleton/code/bit/checkers/columns_h.cpp": "d1297f9052be4f2496e1ff2a77e4db2c0cdbd7d460d489b4c03e50bf317238ce", + "research/e8-bit-carrier-skeleton/code/bit/checkers/legality_h.cpp": "6c1ef2b24e57781d6951c172a1024fc4300e6fd392c9d6672079a7806ab663b3", + "research/e8-bit-carrier-skeleton/code/bit/checkers/json.hpp": "aaf127c04cb31c406e5b04a63f1ae89369fccde6d8fa7cdda1ed4f32dfc5de63", + "research/e8-bit-carrier-skeleton/portable-include/bits/stdc++.h": "420094be2af295eed03a983dd66debbbe9cfb78d8252859f4498a615a0074b99" + }, + "historical_provenance": { + "path": "certificates/selected-result.json", + "commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53", + "role": "historical frontier context; not a runtime dependency" + } +} diff --git a/research/r420-two-sided-compensation/VALIDATION.json b/research/r420-two-sided-compensation/VALIDATION.json new file mode 100644 index 0000000000..c721de6d35 --- /dev/null +++ b/research/r420-two-sided-compensation/VALIDATION.json @@ -0,0 +1,56 @@ +{ + "status": "PASS_SCOPED_FINITE_CONSTRUCTION", + "date_utc": "2026-10-13T05:13:02.460640+00:00", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "python": "3.9.6 (default, May 22 2026, 11:13:45) \n[Clang 21.0.0 (clang-2100.1.1.101)]", + "platform": "macOS-26.5.1-arm64-arm-64bit", + "command": "python3 -B research/r420-two-sided-compensation/verify.py", + "passes": [ + "source and canonical input pins", + "full672-frame E8 audit and660 arbitrary-input columns", + "independent set-valued matrix and full-word replay", + "fixed47-donor optimal receiver assignments", + "8 main negative controls;3 independent controls", + "actual native serialization, exact paths and positive-prefix accounting", + "5/9/11-stage Python and unchanged C++ replay,900/1380/1620 columns,96 built-in bridge controls across both words", + "missing native D ADD passes legality and is rejected by all3 C++ column checkers", + "exact C++/Python receipt agreement", + "isolated optimized Python", + "minimal relocated and recompressed-input reproduction", + "corrupted certificate and source rejection", + "make selected-record-check" + ], + "not_run": [ + "full repository make verify", + "selected frontier cold replay", + "hosted-parent/whole-owner/global invoice and new outer assembly", + "remote CI", + "Lean proof" + ], + "boost": { + "version": "1.85.0", + "archive_url": "https://archives.boost.io/release/1.85.0/source/boost_1_85_0.tar.bz2", + "sha256": "7009fe1faa1697476bdc7027703a2badb84e849b7b0baad5086b087b971f8617", + "verification": "matched official archive metadata SHA256; only headers/license extracted locally" + }, + "publication": "prepared for public pull request by franciscoyne001-svg", + "experiment_overlap": { + "through_pr": 759, + "main_unchanged": true, + "733": "dfe84e09298abc5c5e0074afda59a821e10abfb4", + "742": "6e7a5d271a123886dc7b54ca3180d0b9f9beda5a", + "759": "467b9da6fe130a12d0d6edda310cd6b0efd22a7e" + }, + "submission_overlap": { + "through_pr": 946, + "scope": "200 recent open PRs and complete indexed R420-title, donor, two-sided and8412 searches; not exhaustive novelty guarantee", + "817": "3147cac35c659152d36db1e0e60b9ce4b152c008" + }, + "submission_replay": { + "base_commit": "007664306fff84fbb1c9a1b4053b69f439764034", + "command": "python3 -B research/r420-two-sided-compensation/verify.py", + "result": "PASS_R420_TWO_SIDED D=19922->11510 native_ADDs=26916->18504 saved=8412 columns=660 no_new_kappa", + "official_cpp": "not rerun in submission replay; original unchanged-source C++ receipts retained in NATIVE-CPP.json", + "source_change": "Historical selected-result hash moved from runtime dependency checks to provenance; actual finite checker inputs unchanged." + } +} diff --git a/research/r420-two-sided-compensation/audit_independent.py b/research/r420-two-sided-compensation/audit_independent.py new file mode 100644 index 0000000000..5b47930ada --- /dev/null +++ b/research/r420-two-sided-compensation/audit_independent.py @@ -0,0 +1,358 @@ +#!/usr/bin/env python3 +"""Independent set-valued audit of a frozen two-sided frame-zero D recipe. + +Uses only the standard library and imports neither the producer nor its verifier. +All 660 formal input coordinates are replayed simultaneously as Python sets. +Recipe coordinates: each [destination, source] pair and every transformed_rows +entry uses global register numbers. Helper pairs have disjoint endpoints. Target +receivers are unique and disjoint from all target donors; donors may repeat. +The only candidate word change permitted is D. +""" +from __future__ import annotations + +import argparse +from fractions import Fraction +import gzip +import hashlib +import json +from pathlib import Path +import sys + +BASELINE_SEMANTIC_SHA256 = "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2" +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent + + +class Reject(Exception): + pass + + +def require(condition, message): + if not condition: + raise Reject(message) + + +def load(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def semantic_digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def fresh(n): + return [{i} for i in range(n)] + + +def apply_gates(values, gates, n): + for index, gate in enumerate(gates): + require(isinstance(gate, list) and len(gate) == 3, + f"gate {index}: expected [frame,destination,sources]") + frame, destination, sources = gate + require(type(frame) is int and type(destination) is int, + f"gate {index}: noninteger coordinate") + require(isinstance(sources, list) and sources, f"gate {index}: empty/malformed sources") + operands = [destination] + sources + require(all(type(r) is int and 0 <= r < n for r in operands), + f"gate {index}: operand out of range") + require(len(set(operands)) == len(operands), f"gate {index}: duplicate/self source") + for source in sources: + values[destination].symmetric_difference_update(values[source]) + return values + + +def rational_basis(rows): + """Independent exact row-echelon basis, indexed by leading column.""" + basis = {} + for row in rows: + residual = list(map(Fraction, row)) + for pivot, vector in sorted(basis.items()): + coefficient = residual[pivot] + if coefficient: + residual = [x - coefficient * y for x, y in zip(residual, vector)] + pivot = next((j for j, x in enumerate(residual) if x), None) + if pivot is not None: + coefficient = residual[pivot] + basis[pivot] = [x / coefficient for x in residual] + return basis + + +class NativeReplay: + def __init__(self, word): + self.word = word + self.v = word["v"] + self.n = 2 * self.v + word["R"] + require((word["h"], self.v, word["R"], self.n) == (8, 120, 420, 660), + "unexpected R420 header") + require(word["frames"][0] == [], "frame zero must be empty") + self.frames = [set(frame) for frame in word["frames"]] + self.dimensions = [len(rational_basis(word["lines"][r] for r in frame)) + for frame in word["frames"]] + require(len(word["start"]) == self.n == len(word["final"]), "frame array size mismatch") + for r in range(self.n): + f = word["start"][r] + require(0 <= f < len(self.frames), "invalid start frame") + require(self.frames[f] == ({r} if r < self.v else set()), "invalid register start frame") + + def replay(self, d_override=None, check_frames=True): + word, n, v = self.word, self.n, self.v + values = fresh(n) + current = word["start"][:] + climbs = 0 + + def climb(register, frame): + nonlocal climbs + require(type(frame) is int and 0 <= frame < len(self.frames), "invalid gate frame") + old = current[register] + if old != frame: + require(self.frames[old] <= self.frames[frame] + and self.dimensions[old] < self.dimensions[frame], + f"illegal climb: register {register}, frame {old} -> {frame}") + current[register] = frame + climbs += 1 + + for phase in ("D", "A", "scatter", "B", "C"): + if phase == "scatter": + require(len(word[phase]) == v, "scatter target count mismatch") + require(all(2 * v <= register < n for register in word["ret"]), + "retained total not in helper range") + if check_frames: + require(all(self.dimensions[current[t]] == 0 for t in range(v, 2 * v)), + "target left zero frame before scatter") + retained = [set(values[r]) for r in word["ret"]] + for target, row in enumerate(word[phase], v): + require(len(set(row)) == len(row), "duplicate retained scatter source") + for slot in row: + require(type(slot) is int and 0 <= slot < len(retained), "bad scatter slot") + values[target].symmetric_difference_update(retained[slot]) + continue + gates = d_override if phase == "D" and d_override is not None else word[phase] + for gate in gates: + # Operand validation occurs before frame-index access. + apply_gates(values, [gate], n) + if check_frames: + frame, destination, sources = gate + for register in [destination] + sources: + climb(register, frame) + if check_frames: + for register, frame in enumerate(word["final"]): + climb(register, frame) + if register < v or register >= 2 * v: + require(self.dimensions[frame] == 8, "source/helper final frame not full") + else: + target = register - v + expected = {r for r, line in enumerate(word["lines"]) + if sum(a * b for a, b in zip(line, word["lines"][target])) == 0} + require(self.frames[frame] == expected, "target final frame not target perpendicular") + return values, climbs + + +def mismatches(actual, expected): + bad = [i for i, (a, b) in enumerate(zip(actual, expected)) if a != b] + first = bad[0] if bad else None + return {"count": len(bad), "first_register": first, + "first_symmetric_difference": sorted(actual[first] ^ expected[first]) if bad else []} + + +def check_pairs(pairs, low, high, label): + require(isinstance(pairs, list) and pairs, f"{label} pairs must be nonempty") + used = set() + for pair in pairs: + require(isinstance(pair, list) and len(pair) == 2, f"malformed {label} pair") + destination, source = pair + require(type(destination) is int and type(source) is int + and low <= destination < high and low <= source < high and destination != source, + f"{label} pair has invalid global register coordinates") + require(not ({destination, source} & used), f"{label} pairs are not disjoint") + used.update(pair) + + +def check_target_pairs(pairs, low, high): + require(isinstance(pairs, list) and pairs, "target pairs must be nonempty") + receivers, donors = set(), set() + for pair in pairs: + require(isinstance(pair, list) and len(pair) == 2, "malformed target pair") + receiver, donor = pair + require(type(receiver) is int and type(donor) is int + and low <= receiver < high and low <= donor < high and receiver != donor, + "target pair has invalid global register coordinates") + require(receiver not in receivers, "target receiver repeated") + receivers.add(receiver) + donors.add(donor) + require(not receivers & donors, "modified target receiver used as donor") + + +def fixed_donor_audit(rows, recipe, v): + """Optimal receiver assignment in the explicitly frozen donor-set class.""" + donors = recipe["target_search"]["donors"] + require(isinstance(donors, list) and donors == sorted(set(donors)) and donors, + "frozen donors must be a sorted, unique nonempty list") + require(all(type(d) is int and v <= d < 2*v for d in donors), "frozen donor out of range") + assigned = dict(recipe["target_pairs"]) + require(not set(assigned) & set(donors), "a nominated donor is also a receiver") + require(all(source in donors for source in assigned.values()), "assigned donor not nominated") + positive = {} + for target in range(v, 2*v): + if target in donors: + continue + gains = {donor: len(rows[target-v]) - len(rows[target-v] ^ rows[donor-v]) - 2 + for donor in donors} + best_gain = max(gains.values()) + if best_gain > 0: + require(target in assigned, "profitable receiver omitted from fixed-donor assignment") + require(gains[assigned[target]] == best_gain, "receiver assigned a suboptimal frozen donor") + positive[target] = best_gain + else: + require(target not in assigned, "unprofitable target pair included") + require(set(positive) == set(assigned), "fixed-donor receiver mismatch") + saved = sum(positive.values()) + require(saved == recipe["target_search"]["saved_over_helper_only"], "target saving metadata mismatch") + return {"status": "PASS_OPTIMAL_RECEIVER_ASSIGNMENT_FOR_FROZEN_DONOR_SET", + "nominated_donors": len(donors), "used_donors": len(set(assigned.values())), + "receivers": len(positive), "paid_gain_sum": saved, + "minimum_pair_paid_gain": min(positive.values()), + "maximum_pair_paid_gain": max(positive.values()), + "scope": "One donor per receiver, at most one update per nondonor; no global donor-set optimality claim"} + + +def audit(baseline_path, recipe_path, candidate_path): + baseline, recipe, candidate = map(load, (baseline_path, recipe_path, candidate_path)) + require(semantic_digest(baseline) == BASELINE_SEMANTIC_SHA256, "baseline semantic SHA256 changed") + require(set(candidate) == set(baseline), "candidate header keys changed") + changed = [key for key in baseline if baseline[key] != candidate[key]] + require(changed == ["D"], f"non-D changes or no change: {changed}") + v, n = baseline["v"], 2 * baseline["v"] + baseline["R"] + helper_pairs = recipe["helper_pairs"] + target_pairs = recipe["target_pairs"] + check_pairs(helper_pairs, 2 * v, n, "helper") + check_target_pairs(target_pairs, v, 2 * v) + + rows = [set() for _ in range(v)] + for frame, target, sources in baseline["D"]: + require(frame == 0 and v <= target < 2 * v + and all(2 * v <= source < n for source in sources), "invalid baseline D gate") + for source in sources: + rows[target - v].symmetric_difference_update({source}) + baseline_rows = [set(row) for row in rows] + columns = {source: {target for target, row in enumerate(rows) if source in row} + for source in range(2*v, n)} + helper_gains = [len(columns[source]) - len(columns[source] ^ columns[destination]) - 2 + for destination, source in helper_pairs] + require(all(gain > 0 for gain in helper_gains), "nonpositive paid helper pair gain") + # Compute K H^{-1}: a helper destination-to-source column update. + for destination, source in reversed(helper_pairs): + for row in rows: + if destination in row: + row.symmetric_difference_update({source}) + helper_only_terms = sum(map(len, rows)) + 2 * len(helper_pairs) + require(helper_only_terms == recipe["helper_only_adds"], "helper-only cost metadata mismatch") + require(sum(map(len, baseline_rows)) - helper_only_terms == sum(helper_gains), + "helper pair gains do not add to helper-only saving") + target_assignment = fixed_donor_audit(rows, recipe, v) + # Compute P K H^{-1}: target destination row XOR source row. + for destination, source in target_pairs: + rows[destination - v].symmetric_difference_update(rows[source - v]) + frozen_rows = recipe["transformed_rows"] + require(len(frozen_rows) == v, "transformed row count mismatch") + require(all(row == sorted(set(row)) for row in frozen_rows), "transformed rows not sorted/unique") + require([sorted(row) for row in rows] == frozen_rows, "frozen feed matrix is not P K H^{-1}") + + segments = { + "helper_prepare": [[0, dst, [src]] for dst, src in helper_pairs], + "target_prepare": [[0, dst, [src]] for dst, src in target_pairs], + "feed": [[0, v + target, sorted(row)] for target, row in enumerate(rows) if row], + "target_restore": [[0, dst, [src]] for dst, src in reversed(target_pairs)], + "helper_restore": [[0, dst, [src]] for dst, src in reversed(helper_pairs)], + } + reconstructed = [gate for gates in segments.values() for gate in gates] + require(candidate["D"] == reconstructed, "candidate D differs from independent recipe expansion") + require(all(gate[0] == 0 for gate in reconstructed), "D includes nonzero frame") + d_expected = apply_gates(fresh(n), baseline["D"], n) + d_actual = apply_gates(fresh(n), reconstructed, n) + require(d_actual == d_expected, f"D endpoint mismatch: {mismatches(d_actual, d_expected)}") + require(all(d_actual[r] == {r} for r in list(range(v)) + list(range(2*v, n))), + "D failed to restore source/helper") + + native = NativeReplay(baseline) + expected_full = [{r, r - v} if v <= r < 2*v else {r} for r in range(n)] + baseline_full, baseline_climbs = native.replay() + require(baseline_full == expected_full, "baseline full native sequence fails") + candidate_full, candidate_climbs = native.replay(d_override=reconstructed) + require(candidate_full == expected_full, "candidate full native sequence fails") + require(candidate_climbs == baseline_climbs, "candidate changed native climb count") + + controls = {} + chained_pairs = [pair[:] for pair in target_pairs] + require(len(chained_pairs) >= 2, "need two target pairs for receiver-as-donor control") + chained_pairs[1][1] = chained_pairs[0][0] + try: + check_target_pairs(chained_pairs, v, 2*v) + except Reject as error: + require(str(error) == "modified target receiver used as donor", "wrong shared-donor control rejection") + controls["modified_receiver_as_donor"] = {"rejected": True, "reason": str(error)} + else: + raise Reject("modified receiver as donor was accepted") + for omitted in ("helper_restore", "target_prepare"): + mutant = [gate for name, gates in segments.items() if name != omitted for gate in gates] + dirty_endpoint = apply_gates(fresh(n), mutant, n) + dirty_full, _ = native.replay(d_override=mutant) + endpoint_difference = mismatches(dirty_endpoint, d_expected) + full_difference = mismatches(dirty_full, expected_full) + require(endpoint_difference["count"] and full_difference["count"], + f"negative control {omitted} was not rejected by both replays") + controls["drop_" + omitted] = {"rejected": True, "D_endpoint": endpoint_difference, + "native_full": full_difference} + + baseline_terms = sum(len(gate[2]) for gate in baseline["D"]) + candidate_terms = sum(len(gate[2]) for gate in reconstructed) + require(baseline_terms - candidate_terms == sum(helper_gains) + target_assignment["paid_gain_sum"], + "combined saving does not equal the independently recomputed pair gains") + return { + "status": "PASS", "auditor": "independent standard-library set-valued replay", + "inputs": {"baseline_semantic_sha256": semantic_digest(baseline), "recipe_sha256": digest(recipe_path), + "candidate_sha256": digest(candidate_path)}, + "formal_columns": n, "dirty_helper_columns": baseline["R"], + "changed_word_fields": changed, + "helper_pairs": len(helper_pairs), "target_pairs": len(target_pairs), + "helper_pair_paid_gains": {"sum": sum(helper_gains), "minimum": min(helper_gains), + "maximum": max(helper_gains)}, + "target_fixed_donor_assignment": target_assignment, + "target_basis_verified": "P = I + N with N^2 = 0; repeated donors allowed", + "feed_matrix_verified": "L = P K H^-1", + "D_endpoint_verified": "(x,s,y) -> (x,s,y+K s)", + "native_full_verified": "(x,s,y) -> (x,s,y+x)", + "native_frame_climbs": candidate_climbs, + "frame_audit": "exact rational dimensions and nested inherited frame line sets; unchanged labels", + "segments": {name: {"gates": len(gates), "terms": sum(len(g[2]) for g in gates)} + for name, gates in segments.items()}, + "baseline_D_terms": baseline_terms, "candidate_D_terms": candidate_terms, + "D_term_saving": baseline_terms - candidate_terms, + "negative_controls": controls, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--baseline", type=Path, + default=ROOT / "research/e8-bit-r420/data/bitE8mut-r420.json.gz") + parser.add_argument("--recipe", type=Path, default=HERE / "recipe.json") + parser.add_argument("--candidate", type=Path, default=HERE / "output/candidate.json") + parser.add_argument("--output", type=Path, default=HERE / "independent-audit.json") + args = parser.parse_args() + try: + report = audit(args.baseline, args.recipe, args.candidate) + except (Reject, KeyError, TypeError, ValueError, IndexError) as exc: + print(json.dumps({"status": "REJECT", "reason": str(exc)}, sort_keys=True)) + return 1 + args.output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(json.dumps(report, indent=2, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/research/r420-two-sided-compensation/construct.py b/research/r420-two-sided-compensation/construct.py new file mode 100644 index 0000000000..852aa47588 --- /dev/null +++ b/research/r420-two-sided-compensation/construct.py @@ -0,0 +1,116 @@ +"""Seed-3 finite nomination; OpenAI Codex assistance, Apache-2.0. + +No global optimality claim. Helper matching followed by shared target donors. +""" +import copy +import gzip +import json +import random +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +SOURCE = ROOT / "research/e8-bit-r420/data/bitE8mut-r420.json.gz" + + +def weight(x): + return bin(x).count("1") + + +def nominate(vectors, rng): + """Choose disjoint (changed vector, added vector) pairs with positive net gain.""" + scored = [] + for d in range(len(vectors)): + for s in range(len(vectors)): + if d != s: + gain = weight(vectors[d]) - weight(vectors[d] ^ vectors[s]) - 2 + scored.append((-gain, rng.random(), d, s)) + used, chosen = set(), [] + for minus_gain, tie, d, s in sorted(scored): + if minus_gain < 0 and d not in used and s not in used: + chosen.append((d, s)) + used.update((d, s)) + return chosen + + +def source_rows(word): + rows = [0] * 120 + for f, d, sources in word["D"]: + for s in sources: + rows[d - 120] ^= 1 << (s - 240) + return rows + + +def search(word): + rows = source_rows(word) + columns = [sum(((r >> j) & 1) << i for i, r in enumerate(rows)) for j in range(420)] + rng = random.Random(3) + # Right multiplication by H changes column source by column destination. + column_pairs = nominate(columns, rng) + helper_pairs = [[s + 240, d + 240] for d, s in column_pairs] + for d, s in column_pairs: + columns[d] ^= columns[s] + after_helpers = [sum(((c >> i) & 1) << j for j, c in enumerate(columns)) for i in range(120)] + initial_target_local = nominate(after_helpers, rng) + donors = {s for d, s in initial_target_local} + gains = [[weight(after_helpers[d]) - weight(after_helpers[d] ^ after_helpers[s]) - 2 + for s in range(120)] for d in range(120)] + + def assign(frozen_donors): + pairs, score = [], 0 + for d in range(120): + if d not in frozen_donors: + gain, s = max((gains[d][s], s) for s in frozen_donors) + if gain > 0: + pairs.append((d, s)) + score += gain + return score, pairs + + score, _ = assign(donors) + trace = [(len(donors), score)] + evaluations = 0 + # One bounded extension of the disjoint-pair class after overlap discovery. + for _ in range(30): + options = [(assign(donors ^ {s})[0], s) for s in range(120)] + evaluations += 120 + new_score, s = max(options) + if new_score <= score: + break + donors ^= {s} + score = new_score + trace.append((len(donors), score)) + score, target_local = assign(donors) + target_pairs = [[d + 120, s + 120] for d, s in target_local] + transformed = list(after_helpers) + for d, s in target_local: + transformed[d] ^= transformed[s] + return dict(assignment_seed=3, method="greedy helper matching then shared target donors", + helper_pairs=helper_pairs, target_pairs=target_pairs, + transformed_rows=[[j + 240 for j in range(420) if r >> j & 1] for r in transformed], + helper_only_adds=sum(map(weight, after_helpers)) + 2 * len(helper_pairs), + searched_orientations=dict(helper=420*419, target=120*119), + target_search=dict(method="best assignment to donors, at most 30 strictly improving single-donor toggles", + donors=sorted(s+120 for s in donors), + saved_over_helper_only=score, trace=[list(x) for x in trace], + evaluated_toggle_sets=evaluations, maximum_iterations=30)) + + +def build(word, recipe): + hp = [[0, d, [s]] for d, s in recipe["helper_pairs"]] + tp = [[0, d, [s]] for d, s in recipe["target_pairs"]] + feed = [[0, i + 120, row] for i, row in enumerate(recipe["transformed_rows"]) if row] + out = copy.deepcopy(word) + out["D"] = hp + tp + feed + list(reversed(tp)) + list(reversed(hp)) + return out + + +if __name__ == "__main__": + word = json.load(gzip.open(SOURCE, "rt")) + recipe = search(word) + out = build(word, recipe) + (HERE / "recipe.json").write_text(json.dumps(recipe, indent=2) + "\n") + (HERE / "output").mkdir(exist_ok=True) + (HERE / "output/candidate.json").write_text(json.dumps(out, separators=(",", ":")) + "\n") + print("D", sum(len(g[2]) for g in word["D"]), "->", sum(len(g[2]) for g in out["D"]), + "helper_pairs", len(recipe["helper_pairs"]), "target_pairs", len(recipe["target_pairs"]), + "helper_only", recipe["helper_only_adds"]) diff --git a/research/r420-two-sided-compensation/independent-audit.json b/research/r420-two-sided-compensation/independent-audit.json new file mode 100644 index 0000000000..3932df2d24 --- /dev/null +++ b/research/r420-two-sided-compensation/independent-audit.json @@ -0,0 +1,175 @@ +{ + "D_endpoint_verified": "(x,s,y) -> (x,s,y+K s)", + "D_term_saving": 8412, + "auditor": "independent standard-library set-valued replay", + "baseline_D_terms": 19922, + "candidate_D_terms": 11510, + "changed_word_fields": [ + "D" + ], + "dirty_helper_columns": 420, + "feed_matrix_verified": "L = P K H^-1", + "formal_columns": 660, + "frame_audit": "exact rational dimensions and nested inherited frame line sets; unchanged labels", + "helper_pair_paid_gains": { + "maximum": 108, + "minimum": 2, + "sum": 6934 + }, + "helper_pairs": 202, + "inputs": { + "baseline_semantic_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2", + "candidate_sha256": "631ddd204e4ddc2760a4e90b4b629d6fc3bb08f0d540acfa2246bab877ce7c72", + "recipe_sha256": "b4586ab5479646e2d0860f0eca2e13232afdc08c41cf08c0e0949ab36760c684" + }, + "native_frame_climbs": 2940, + "native_full_verified": "(x,s,y) -> (x,s,y+x)", + "negative_controls": { + "drop_helper_restore": { + "D_endpoint": { + "count": 202, + "first_register": 242, + "first_symmetric_difference": [ + 470 + ] + }, + "native_full": { + "count": 322, + "first_register": 120, + "first_symmetric_difference": [ + 240, + 248, + 257, + 259, + 260, + 266, + 268, + 280, + 281, + 287, + 296, + 298, + 300, + 307, + 323, + 326, + 329, + 336, + 338, + 348, + 350, + 351, + 352, + 357, + 365, + 369, + 372, + 377, + 384, + 385, + 389, + 393, + 398, + 406, + 411, + 420, + 421, + 434, + 443, + 448, + 450, + 451, + 452, + 456, + 458, + 460, + 474, + 478, + 483, + 484, + 493, + 497, + 502, + 509, + 516, + 521, + 527, + 528, + 544, + 551, + 559, + 565, + 575, + 581, + 583, + 597, + 600, + 608, + 614, + 615, + 633, + 634, + 650, + 656 + ] + }, + "rejected": true + }, + "drop_target_prepare": { + "D_endpoint": { + "count": 68, + "first_register": 121, + "first_symmetric_difference": [ + 127 + ] + }, + "native_full": { + "count": 68, + "first_register": 121, + "first_symmetric_difference": [ + 127 + ] + }, + "rejected": true + }, + "modified_receiver_as_donor": { + "reason": "modified target receiver used as donor", + "rejected": true + } + }, + "segments": { + "feed": { + "gates": 120, + "terms": 10970 + }, + "helper_prepare": { + "gates": 202, + "terms": 202 + }, + "helper_restore": { + "gates": 202, + "terms": 202 + }, + "target_prepare": { + "gates": 68, + "terms": 68 + }, + "target_restore": { + "gates": 68, + "terms": 68 + } + }, + "status": "PASS", + "target_basis_verified": "P = I + N with N^2 = 0; repeated donors allowed", + "target_fixed_donor_assignment": { + "maximum_pair_paid_gain": 48, + "minimum_pair_paid_gain": 3, + "nominated_donors": 47, + "paid_gain_sum": 1478, + "receivers": 68, + "scope": "One donor per receiver, at most one update per nondonor; no global donor-set optimality claim", + "status": "PASS_OPTIMAL_RECEIVER_ASSIGNMENT_FOR_FROZEN_DONOR_SET", + "used_donors": 47 + }, + "target_pairs": 68 +} diff --git a/research/r420-two-sided-compensation/native.py b/research/r420-two-sided-compensation/native.py new file mode 100644 index 0000000000..3fe9bc7f77 --- /dev/null +++ b/research/r420-two-sided-compensation/native.py @@ -0,0 +1,409 @@ +"""Export and audit the finite R420 candidate at the native record boundary. + +Only the Python standard library is required. The upstream exporter is run +unchanged; optional upstream C++ checkers need a compiler and Boost headers. +The Python bridged replay is a separately identified fallback, not a claim that +the official C++ checkers ran. No pricing or asymptotic improvement is inferred. +Its schedule and prefix formula follow the Apache-2.0 columns_k.cpp checker by +Dylan Crow and DaysSky (with Claude assistance); it is a port of that check, +not an independent derivation of the bridged composition theorem. + +Prepared with substantial OpenAI Codex assistance; Apache-2.0. +""" + +import argparse +from collections import Counter +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import struct +import subprocess +import sys + + +HERE = Path(__file__).resolve().parent +RESEARCH = HERE.parent +SKELETON = RESEARCH / "e8-bit-carrier-skeleton" +BIT = SKELETON / "code/bit" +BASELINE = RESEARCH / "e8-bit-r420/data/bitE8mut-r420.json.gz" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def load_word(path): + with (gzip.open(path, "rt") if str(path).endswith(".gz") else open(path)) as handle: + return json.load(handle) + + +def digest(data): + return hashlib.sha256(data).hexdigest() + + +def write_json(path, data): + path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n") + + +def run_logged(command, logfile): + completed = subprocess.run(list(map(str, command)), capture_output=True, text=True) + logfile.write_text("$ " + " ".join(map(str, command)) + "\n" + completed.stdout + completed.stderr) + return completed.returncode + + +def export(word, out): + records = out / "records" + records.mkdir(parents=True, exist_ok=True) + require(run_logged([sys.executable, "-I", "-B", BIT / "export_records.py", word, records], + out / "export.log") == 0, "unchanged native export failed") + raw = (records / "249-records.bin").read_bytes() + require(len(raw) % 24 == 0, "native record alignment") + rows = list(struct.iter_unpack("<6i", raw)) + state = json.loads((records / "249-states.json").read_text()) + frames = json.loads((records / "frames.json").read_text())["frames"] + return rows, state, frames + + +def record_legality(rows, state, frames): + """Exact integer geometry/lifecycle audit, with no owner selection present.""" + n = state["n"] + frame = {int(k): v for k, v in frames.items()} + current = [state["initial"][str(i)] for i in range(n)] + [state["ZERO"]] + opened = None + containment = {} + paid = Counter() + counts = Counter() + for index, (op, a, b, c, f, z) in enumerate(rows): + require(0 <= a <= n and (op == 0 or 0 <= b <= n), "record role range") + counts[op] += 1 + if op == 0: + require(a != n or opened is not None, "MOVE inactive temporary") + key = (b, c) + if key not in containment: + containment[key] = frame[b]["dim"] <= frame[c]["dim"] and all( + sum(x * y for x, y in zip(row, ann)) == 0 + for row in frame[b]["B"] for ann in frame[c]["A"]) + require(current[a] == b and containment[key] and frame[c]["dim"] - frame[b]["dim"] == f, + "illegal/mispriced MOVE at %d" % index) + current[a] = c + if f: + paid[f] += 1 + elif op == 1: + require(current[a] == current[b] == f and a != b, "ADD common frame or self ADD") + require(n not in (a, b) or opened is not None, "ADD inactive temporary") + require(opened is None or a not in (opened, n), "copied source or temporary mutated") + elif op == 2: + require(opened is None and b == n and current[a] == c, "COPY lifecycle") + require(z == frame[c]["dim"], "COPY rank") + opened = a + current[n] = f + paid[z] += 1 + elif op == 3: + require(opened is not None and a == opened and b == n and current[a] == c and current[n] == f, + "ERASE lifecycle") + opened = None + else: + raise ValueError("unknown native opcode") + require(opened is None and counts[2] == counts[3] == 9, "copy endpoint") + require(current[:n] == [state["final"][str(i)] for i in range(n)], "native final frames") + return {"status": "PASS_PYTHON_NATIVE_RECORD_LEGALITY", "records": len(rows), + "moves": counts[0], "binary_ADDs": counts[1], "copies": counts[2], "erasures": counts[3], + "paid_histogram": dict(sorted(paid.items())), "rank_mass": sum(k * v for k, v in paid.items()), + "binary_ADDs_by_phase": dict(sorted(Counter(row[5] for row in rows if row[0] == 1).items())), + "containment_pairs_checked": len(containment)} + + +def scalar_stream(rows, n): + stream = [] + for op, a, b, c, f, z in rows: + if op == 1: + stream.append((0, a, b, c)) + elif op == 2: + stream.append((1, n, a, 0)) + elif op == 3: + stream.append((2, n, a, 0)) + return stream + + +def prefix_bounds(stream, n): + result = [] + for reverse in (False, True): + values = [1] * (n + 1) + largest = 1 + opened = False + for kind, dst, src, coefficient in (reversed(stream) if reverse else stream): + if reverse and kind: + kind = 3 - kind + if kind == 0: + values[dst] += abs(coefficient) * values[src] + largest = max(largest, values[dst]) + elif kind == 1: + require(not opened, "prefix COPY nesting") + values[n] = values[src] + opened = True + else: + require(opened, "prefix ERASE without COPY") + values[n] = 0 + opened = False + require(not opened, "prefix copy closure") + result.append({"reverse": reverse, "cancellation_free_signed_row_l1_upper": str(largest), + "bits": largest.bit_length()}) + forward, backward = [int(item["cancellation_free_signed_row_l1_upper"]) for item in result] + payload = 64 * forward ** 3 * backward ** 2 + return {"signed_lift_prefix": result, "payload_prefix_upper": str(payload), + "payload_prefix_bits": payload.bit_length(), "payload_under_2_power_104": payload < 2 ** 104} + + +def schedule(k): + stages = 2 * k + 1 + active = [] + reverse = [] + bridges = [[] for _ in range(stages)] + for stage in range(stages): + pair = 1 if stage < 3 else (stage + 1) // 2 + backward = stage == 1 or (stage >= 3 and stage % 2 == 1) + x, y = 2 * (pair - 1), 2 * (pair - 1) + 1 + active.append((y, x) if backward else (x, y)) + reverse.append(backward) + for pair in range(2, k + 1): + x, y = 2 * (pair - 1), 2 * (pair - 1) + 1 + bridges[2 * pair - 3].extend(((x - 2, x), (y, y - 2))) + bridges[2 * pair - 2].extend(((y, y - 2), (x - 2, x))) + for pair in range(k, 1, -1): + x, y = 2 * (pair - 1), 2 * (pair - 1) + 1 + bridges[-1].extend(((y - 2, y), (x, x - 2))) + return active, reverse, bridges + + +def bridged_replay(stream, state, k): + """Python-integer bitsets carry every independent input column at once.""" + v, r, n = state["v"], state["R"], state["n"] + live = 2 * k * v + r + values = [1 << i for i in range(live)] + [0] + active, backward, bridges = schedule(k) + for stage, (xb, yb) in enumerate(active): + mapping = [xb * v + i for i in range(v)] + [yb * v + i for i in range(v)] + list(range(2 * k * v, live + 1)) + opened = False + copies = 0 + for kind, dst, src, coefficient in (reversed(stream) if backward[stage] else stream): + if backward[stage] and kind: + kind = 3 - kind + d, s = mapping[dst], mapping[src] + if kind == 0: + if coefficient % 2: + values[d] ^= values[s] + elif kind == 1: + require(not opened, "physical COPY nesting") + values[live] = values[s] + opened = True + copies += 1 + else: + require(opened, "physical ERASE without COPY") + values[live] = 0 + opened = False + require(not opened and copies == 9, "stage COPY count") + if stage == 0: + require(all(values[i] == ((1 << i) ^ ((1 << (i - v)) if v <= i < 2 * v else 0)) + for i in range(live)), "local defining decoder on all physical columns") + for dst, src in bridges[stage]: + for i in range(v): + values[dst * v + i] ^= values[src * v + i] + for bank in range(0, 2 * k, 2): + for i in range(v): + a, b = bank * v + i, (bank + 1) * v + i + values[a], values[b] = values[b], values[a] + require(values[live] == 0 and all(values[i] == 1 << i for i in range(live)), "bridged endpoint") + bridge_count = sum(map(len, bridges)) + controls = [] + for omit in range(bridge_count): + banks = [1 << i for i in range(2 * k)] + number = 0 + for stage, (xb, yb) in enumerate(active): + banks[yb] ^= banks[xb] + for dst, src in bridges[stage]: + if number != omit: + banks[dst] ^= banks[src] + number += 1 + for bank in range(0, 2 * k, 2): + banks[bank], banks[bank + 1] = banks[bank + 1], banks[bank] + rejected = any(banks[i] != 1 << i for i in range(2 * k)) + require(rejected, "vacuous omitted bridge negative control") + controls.append({"omit_bridge": omit, "rejected": True}) + return {"status": "PASS_PYTHON_NATIVE_ALL_PHYSICAL_COLUMNS", "stages": 2 * k + 1, + "formal_columns_checked": live, "bridge_additions": bridge_count * v, + "fresh_center_copies": (2 * k + 1) * 9, "negative_controls": controls} + + +def cpp_missing_d_control(out, binaries): + """Run the unchanged C++ checkers on one malformed native ADD stream.""" + folder = out / "candidate" + rows = list(struct.iter_unpack("<6i", (folder / "records/249-records.bin").read_bytes())) + index = next(i for i, row in enumerate(rows) if row[0] == 1 and row[5] == 1) + mutant = rows[:index] + rows[index + 1:] + mutant_path = out / "missing-D-ADD.bin" + mutant_path.write_bytes(b"".join(struct.pack("<6i", *row) for row in mutant)) + cout = out / "missing-D-cout" + shutil.copytree(folder / "cout", cout, dirs_exist_ok=True) + shutil.copyfile(mutant_path, cout / "COHORT249-RECORDS.bin") + require(run_logged([binaries / "legality", folder / "cin", cout, cout / "legality.json"], + out / "missing-D-legality.log") == 0, "missing-D control changed native legality") + rejections = [] + for stages in (5, 9, 11): + log = out / ("missing-D-columns%d.log" % stages) + code = run_logged([binaries / ("columns%d" % stages), mutant_path, + out / ("missing-D-columns%d.json" % stages)], log) + require(code != 0 and "local defining-decoder full formal column" in log.read_text(), + "C++ missing-D control accepted or rejected for wrong reason") + rejections.append({"stages": stages, "rejected": True, "returncode": code, + "reason": "local defining-decoder full formal column"}) + return {"status": "PASS_CPP_MISSING_D_ADD_NEGATIVE_CONTROL", "record_index": index, + "removed_record": list(rows[index]), "legality_passed": True, + "native_all_column_rejections": rejections} + + +def compare_cpp_python(receipts, python_reports): + for name, cpp in receipts.items(): + py = python_reports[name] + legality = py["legality"] + hist = {int(k): value for k, value in legality["paid_histogram"].items()} + for cpp_key, py_key in (("records", "records"), ("common_frame_ADDs", "binary_ADDs"), + ("nested_MOVEs", "moves"), ("copies", "copies"), + ("erasures", "erasures"), ("rank_mass", "rank_mass")): + require(cpp["legality"][cpp_key] == legality[py_key], "C++/Python legality mismatch") + require(dict(cpp["legality"]["paid_histogram"]) == hist, "C++/Python paid histogram mismatch") + for stage, physical in zip((5, 9, 11), py["physical_columns"]): + receipt = cpp["columns%d" % stage] + for key in ("signed_lift_prefix", "payload_prefix_upper", "payload_prefix_bits"): + require(receipt[key] == py["prefix"][key], "C++/Python exact prefix mismatch") + require(receipt["local_scalar_additions"] == legality["binary_ADDs"], "C++/Python ADD mismatch") + require(dict(receipt["local_raw_H"]) == hist, "C++/Python column profile mismatch") + for key in ("formal_columns_checked", "bridge_additions", "fresh_center_copies", "negative_controls"): + require(receipt[key] == physical[key], "C++/Python physical column receipt mismatch") + return {"status": "PASS_CPP_PYTHON_EXACT_RECEIPT_COMPARISON", "datasets": sorted(receipts), + "checks": ["legality counts", "paid histogram and rank mass", "binary ADD counts", + "exact forward and reverse prefix bounds", "payload and bit lengths", + "5/9/11 column counts and omitted-bridge controls"]} + + +def cpp_checks(out, datasets, boost_include, cxx, python_reports=None): + compiler = shutil.which(cxx) + paths = ([Path(boost_include)] if boost_include else []) + [ + Path(os.environ.get("BOOST_INCLUDE", "/usr/include")), + Path("/opt/homebrew/include"), Path("/usr/local/include")] + boost = next((p for p in paths if (p / "boost/multiprecision/cpp_int.hpp").is_file()), None) + availability = {"compiler_available": compiler is not None, "boost_headers_available": boost is not None} + if compiler is None or boost is None: + availability["status"] = ("NOT_RUN_MISSING_COMPILER_AND_BOOST_HEADERS" if compiler is None and boost is None + else "NOT_RUN_MISSING_COMPILER" if compiler is None + else "NOT_RUN_MISSING_BOOST_HEADERS") + return availability + binaries = out / "bin" + binaries.mkdir(exist_ok=True) + checks = BIT / "checkers" + common = [compiler, "-O2", "-std=c++17", "-DHDIM=8", "-DNCOPY=9", "-DVPORTS=120", "-DRHELP=420", + "-I" + str(SKELETON / "portable-include"), "-I" + str(checks), "-I" + str(boost)] + builds = [("legality", "legality_h.cpp", []), ("columns5", "columns_h.cpp", []), + ("columns9", "columns_k.cpp", ["-DKPAIRS=4"]), + ("columns11", "columns_k.cpp", ["-DKPAIRS=5"])] + for name, source, options in builds: + require(run_logged(common + options + ["-o", binaries / name, checks / source], + out / (name + "-compile.log")) == 0, "C++ compilation failed: " + name) + result = {} + for name in datasets: + folder = out / name + require(run_logged([sys.executable, "-I", "-B", BIT / "regression/stage_cohort.py", + folder / "records", folder / "records", folder / "cin", folder / "cout"], + folder / "stage.log") == 0, "cohort staging failed") + result[name] = {} + for binary, _, _ in builds: + receipt = folder / (binary + ".json") + args = [folder / "cin", folder / "cout", receipt] if binary == "legality" else [ + folder / "cout/COHORT249-RECORDS.bin", receipt] + require(run_logged([binaries / binary] + args, folder / (binary + ".log")) == 0, + "official C++ checker failed: " + name + "/" + binary) + result[name][binary] = {key: value for key, value in json.loads(receipt.read_text()).items() + if key not in ("seconds", "local_scalar_stream")} + negative = cpp_missing_d_control(out, binaries) + comparison = compare_cpp_python(result, python_reports) if python_reports is not None else None + return dict(availability, status="PASS_UNCHANGED_CPP_5_9_11_STAGE_CHECKERS", receipts=result, + missing_D_negative_control=negative, python_receipt_comparison=comparison) + + +def missing_d_control(rows, state, frames, out): + index = next(i for i, row in enumerate(rows) if row[0] == 1 and row[5] == 1) + mutant = rows[:index] + rows[index + 1:] + (out / "missing-D-ADD.bin").write_bytes(b"".join(struct.pack("<6i", *row) for row in mutant)) + legality = record_legality(mutant, state, frames) + stream = scalar_stream(mutant, state["n"]) + rejections = [] + for k in (2, 4, 5): + try: + bridged_replay(stream, state, k) + except ValueError as error: + require(str(error) == "local defining decoder on all physical columns", "wrong mutation rejection") + rejections.append({"stages": 2 * k + 1, "rejected": True, "reason": str(error)}) + else: + raise ValueError("missing-D ADD corruption accepted at %d stages" % (2 * k + 1)) + return {"status": "PASS_MISSING_D_ADD_NEGATIVE_CONTROL", "record_index": index, + "removed_record": list(rows[index]), "legality_status": legality["status"], + "native_all_column_rejections": rejections} + + +def run(candidate_path, out, baseline=BASELINE, boost_include=None, cxx="c++"): + """Write native audit artifacts to out and return the path-free result dict.""" + out = Path(out).resolve() + out.mkdir(parents=True, exist_ok=True) + result = {"status": "IN_PROGRESS", "exporter_sha256": digest((BIT / "export_records.py").read_bytes()), + "upstream_columns_k_sha256": digest((BIT / "checkers/columns_k.cpp").read_bytes()), + "python_replay_provenance": "Python port of the upstream columns_k schedule and prefix formula; not an official C++ run or an independent theorem proof.", + "scope": "Finite native geometry, paid paths, ADD counts, exact F2 columns and positive prefix bounds. No new price or kappa."} + datasets = {} + for name, word in (("baseline", Path(baseline)), ("candidate", Path(candidate_path))): + rows, state, frames = export(word.resolve(), out / name) + datasets[name] = (rows, state, frames) + stream = scalar_stream(rows, state["n"]) + result[name] = {"input_sha256": digest(word.read_bytes()), "legality": record_legality(rows, state, frames), + "prefix": prefix_bounds(stream, state["n"]), + "physical_columns": [bridged_replay(stream, state, k) for k in (2, 4, 5)]} + require(result[name]["prefix"]["payload_under_2_power_104"], "positive prefix exceeds inherited cutoff") + base, candidate = datasets["baseline"], datasets["candidate"] + paths = [[row for row in data[0] if row[0] != 1] for data in (base, candidate)] + require(paths[0] == paths[1], "MOVE/COPY/ERASE paths changed") + for filename in ("frames.json", "249-states.json"): + require((out / "baseline/records" / filename).read_bytes() == + (out / "candidate/records" / filename).read_bytes(), filename + " changed") + bleg, cleg = [result[name]["legality"] for name in ("baseline", "candidate")] + require(bleg["paid_histogram"] == cleg["paid_histogram"] and bleg["rank_mass"] == cleg["rank_mass"], + "paid profile changed") + result["comparison"] = {"exact_MOVE_COPY_ERASE_paths_equal": True, "frames_bytes_equal": True, + "states_bytes_equal": True, "paid_histogram_equal": True, + "paid_rank_mass_equal": True, "non_ADD_records": len(paths[0]), + "non_ADD_stream_sha256": digest(b"".join(struct.pack("<6i", *row) for row in paths[0])), + "binary_ADDs_saved": bleg["binary_ADDs"] - cleg["binary_ADDs"]} + result["native_missing_D_negative_control"] = missing_d_control(*candidate, out) + result["official_cpp"] = cpp_checks(out, datasets, boost_include, cxx, result) + result["status"] = "PASS_NATIVE_PYTHON_AUDIT" + write_json(out / "RESULT.json", result) + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("candidate", nargs="?", type=Path, default=HERE / "output/candidate.json") + parser.add_argument("--baseline", type=Path, default=BASELINE) + parser.add_argument("--out", type=Path, default=HERE / "output/native") + parser.add_argument("--boost-include") + parser.add_argument("--cxx", default=os.environ.get("CXX", "c++")) + args = parser.parse_args() + result = run(args.candidate, args.out, args.baseline, args.boost_include, args.cxx) + print(json.dumps({"status": result["status"], "comparison": result["comparison"], + "official_cpp": result["official_cpp"]["status"], + "receipt": str(args.out.resolve() / "RESULT.json")}, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/r420-two-sided-compensation/recipe.json b/research/r420-two-sided-compensation/recipe.json new file mode 100644 index 0000000000..fcb5447329 --- /dev/null +++ b/research/r420-two-sided-compensation/recipe.json @@ -0,0 +1,12426 @@ +{ + "assignment_seed": 3, + "method": "greedy helper matching then shared target donors", + "helper_pairs": [ + [ + 552, + 521 + ], + [ + 286, + 296 + ], + [ + 275, + 448 + ], + [ + 477, + 249 + ], + [ + 425, + 415 + ], + [ + 433, + 280 + ], + [ + 395, + 369 + ], + [ + 380, + 351 + ], + [ + 354, + 340 + ], + [ + 613, + 637 + ], + [ + 404, + 304 + ], + [ + 435, + 451 + ], + [ + 549, + 584 + ], + [ + 371, + 389 + ], + [ + 360, + 350 + ], + [ + 386, + 365 + ], + [ + 370, + 348 + ], + [ + 429, + 319 + ], + [ + 419, + 403 + ], + [ + 263, + 472 + ], + [ + 313, + 422 + ], + [ + 463, + 289 + ], + [ + 547, + 586 + ], + [ + 582, + 551 + ], + [ + 639, + 615 + ], + [ + 558, + 527 + ], + [ + 602, + 650 + ], + [ + 511, + 493 + ], + [ + 376, + 372 + ], + [ + 413, + 329 + ], + [ + 532, + 565 + ], + [ + 453, + 300 + ], + [ + 531, + 566 + ], + [ + 621, + 633 + ], + [ + 442, + 277 + ], + [ + 504, + 423 + ], + [ + 540, + 604 + ], + [ + 550, + 583 + ], + [ + 400, + 324 + ], + [ + 467, + 268 + ], + [ + 290, + 516 + ], + [ + 303, + 454 + ], + [ + 367, + 341 + ], + [ + 305, + 420 + ], + [ + 627, + 248 + ], + [ + 272, + 436 + ], + [ + 595, + 655 + ], + [ + 295, + 452 + ], + [ + 358, + 336 + ], + [ + 392, + 505 + ], + [ + 337, + 362 + ], + [ + 414, + 317 + ], + [ + 325, + 410 + ], + [ + 616, + 640 + ], + [ + 622, + 634 + ], + [ + 375, + 390 + ], + [ + 345, + 394 + ], + [ + 430, + 311 + ], + [ + 449, + 291 + ], + [ + 409, + 431 + ], + [ + 308, + 312 + ], + [ + 378, + 385 + ], + [ + 399, + 393 + ], + [ + 416, + 307 + ], + [ + 461, + 445 + ], + [ + 282, + 434 + ], + [ + 533, + 619 + ], + [ + 570, + 278 + ], + [ + 523, + 559 + ], + [ + 638, + 614 + ], + [ + 427, + 598 + ], + [ + 383, + 387 + ], + [ + 580, + 544 + ], + [ + 601, + 649 + ], + [ + 620, + 632 + ], + [ + 596, + 656 + ], + [ + 446, + 273 + ], + [ + 469, + 479 + ], + [ + 529, + 539 + ], + [ + 548, + 585 + ], + [ + 412, + 323 + ], + [ + 279, + 462 + ], + [ + 610, + 600 + ], + [ + 625, + 528 + ], + [ + 498, + 502 + ], + [ + 659, + 608 + ], + [ + 603, + 346 + ], + [ + 253, + 484 + ], + [ + 355, + 497 + ], + [ + 252, + 259 + ], + [ + 246, + 240 + ], + [ + 568, + 495 + ], + [ + 391, + 515 + ], + [ + 475, + 465 + ], + [ + 407, + 417 + ], + [ + 492, + 338 + ], + [ + 534, + 509 + ], + [ + 243, + 456 + ], + [ + 255, + 474 + ], + [ + 247, + 271 + ], + [ + 251, + 260 + ], + [ + 438, + 287 + ], + [ + 631, + 508 + ], + [ + 569, + 575 + ], + [ + 457, + 437 + ], + [ + 314, + 402 + ], + [ + 455, + 443 + ], + [ + 468, + 257 + ], + [ + 288, + 283 + ], + [ + 334, + 320 + ], + [ + 293, + 458 + ], + [ + 306, + 326 + ], + [ + 267, + 478 + ], + [ + 459, + 364 + ], + [ + 285, + 447 + ], + [ + 359, + 342 + ], + [ + 327, + 347 + ], + [ + 379, + 373 + ], + [ + 441, + 269 + ], + [ + 444, + 332 + ], + [ + 440, + 330 + ], + [ + 382, + 343 + ], + [ + 651, + 406 + ], + [ + 242, + 470 + ], + [ + 439, + 352 + ], + [ + 418, + 315 + ], + [ + 265, + 264 + ], + [ + 476, + 245 + ], + [ + 261, + 483 + ], + [ + 302, + 292 + ], + [ + 530, + 514 + ], + [ + 256, + 266 + ], + [ + 381, + 597 + ], + [ + 401, + 361 + ], + [ + 310, + 363 + ], + [ + 396, + 428 + ], + [ + 318, + 450 + ], + [ + 328, + 421 + ], + [ + 368, + 384 + ], + [ + 250, + 487 + ], + [ + 464, + 377 + ], + [ + 466, + 398 + ], + [ + 297, + 432 + ], + [ + 557, + 658 + ], + [ + 471, + 301 + ], + [ + 274, + 339 + ], + [ + 374, + 460 + ], + [ + 426, + 357 + ], + [ + 284, + 397 + ], + [ + 496, + 281 + ], + [ + 294, + 366 + ], + [ + 322, + 507 + ], + [ + 349, + 581 + ], + [ + 344, + 331 + ], + [ + 316, + 353 + ], + [ + 244, + 411 + ], + [ + 333, + 335 + ], + [ + 574, + 545 + ], + [ + 561, + 262 + ], + [ + 606, + 254 + ], + [ + 657, + 388 + ], + [ + 270, + 299 + ], + [ + 624, + 473 + ], + [ + 405, + 298 + ], + [ + 636, + 276 + ], + [ + 579, + 408 + ], + [ + 538, + 309 + ], + [ + 518, + 482 + ], + [ + 560, + 424 + ], + [ + 571, + 535 + ], + [ + 499, + 241 + ], + [ + 512, + 494 + ], + [ + 623, + 489 + ], + [ + 647, + 588 + ], + [ + 491, + 321 + ], + [ + 556, + 520 + ], + [ + 577, + 541 + ], + [ + 481, + 258 + ], + [ + 488, + 567 + ], + [ + 564, + 506 + ], + [ + 645, + 590 + ], + [ + 609, + 626 + ], + [ + 587, + 546 + ], + [ + 618, + 635 + ], + [ + 642, + 593 + ], + [ + 563, + 522 + ], + [ + 605, + 648 + ], + [ + 612, + 641 + ], + [ + 526, + 562 + ], + [ + 643, + 592 + ], + [ + 589, + 646 + ], + [ + 591, + 644 + ], + [ + 537, + 573 + ], + [ + 543, + 524 + ], + [ + 553, + 517 + ], + [ + 654, + 599 + ], + [ + 519, + 555 + ], + [ + 572, + 536 + ], + [ + 542, + 578 + ], + [ + 607, + 628 + ], + [ + 503, + 356 + ], + [ + 576, + 652 + ] + ], + "target_pairs": [ + [ + 121, + 127 + ], + [ + 122, + 124 + ], + [ + 125, + 120 + ], + [ + 126, + 123 + ], + [ + 128, + 134 + ], + [ + 129, + 132 + ], + [ + 131, + 133 + ], + [ + 135, + 162 + ], + [ + 136, + 138 + ], + [ + 137, + 143 + ], + [ + 140, + 138 + ], + [ + 141, + 139 + ], + [ + 142, + 223 + ], + [ + 146, + 151 + ], + [ + 147, + 199 + ], + [ + 148, + 145 + ], + [ + 149, + 144 + ], + [ + 150, + 188 + ], + [ + 155, + 157 + ], + [ + 158, + 152 + ], + [ + 160, + 165 + ], + [ + 161, + 199 + ], + [ + 166, + 163 + ], + [ + 167, + 211 + ], + [ + 168, + 188 + ], + [ + 170, + 169 + ], + [ + 173, + 174 + ], + [ + 175, + 188 + ], + [ + 176, + 182 + ], + [ + 177, + 183 + ], + [ + 178, + 198 + ], + [ + 179, + 199 + ], + [ + 180, + 172 + ], + [ + 181, + 198 + ], + [ + 184, + 171 + ], + [ + 186, + 171 + ], + [ + 187, + 169 + ], + [ + 189, + 171 + ], + [ + 190, + 188 + ], + [ + 191, + 185 + ], + [ + 192, + 188 + ], + [ + 194, + 193 + ], + [ + 195, + 183 + ], + [ + 196, + 198 + ], + [ + 197, + 199 + ], + [ + 200, + 156 + ], + [ + 202, + 207 + ], + [ + 205, + 154 + ], + [ + 206, + 203 + ], + [ + 208, + 182 + ], + [ + 209, + 211 + ], + [ + 210, + 212 + ], + [ + 214, + 153 + ], + [ + 215, + 213 + ], + [ + 218, + 223 + ], + [ + 219, + 222 + ], + [ + 220, + 217 + ], + [ + 221, + 216 + ], + [ + 224, + 230 + ], + [ + 226, + 228 + ], + [ + 227, + 213 + ], + [ + 229, + 151 + ], + [ + 231, + 225 + ], + [ + 232, + 238 + ], + [ + 234, + 236 + ], + [ + 235, + 127 + ], + [ + 237, + 127 + ], + [ + 239, + 233 + ] + ], + "transformed_rows": [ + [ + 243, + 244, + 246, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 261, + 262, + 267, + 275, + 282, + 286, + 290, + 293, + 295, + 301, + 305, + 306, + 309, + 318, + 328, + 347, + 349, + 352, + 355, + 358, + 360, + 363, + 364, + 368, + 370, + 371, + 373, + 374, + 376, + 378, + 380, + 381, + 386, + 395, + 398, + 399, + 405, + 411, + 412, + 413, + 416, + 423, + 426, + 433, + 435, + 438, + 439, + 453, + 455, + 464, + 466, + 467, + 468, + 478, + 482, + 487, + 489, + 492, + 496, + 498, + 502, + 511, + 513, + 514, + 523, + 532, + 534, + 550, + 552, + 558, + 569, + 580, + 581, + 582, + 596, + 602, + 610, + 621, + 622, + 625, + 627, + 638, + 639, + 651, + 652, + 658, + 659 + ], + [ + 242, + 255, + 263, + 267, + 274, + 281, + 282, + 288, + 290, + 293, + 305, + 308, + 313, + 316, + 320, + 325, + 326, + 327, + 328, + 331, + 334, + 337, + 338, + 339, + 344, + 345, + 346, + 349, + 359, + 368, + 370, + 373, + 374, + 375, + 377, + 378, + 380, + 381, + 382, + 384, + 386, + 388, + 391, + 392, + 396, + 398, + 399, + 401, + 407, + 411, + 413, + 414, + 416, + 421, + 426, + 433, + 435, + 438, + 441, + 444, + 455, + 460, + 461, + 463, + 464, + 466, + 467, + 468, + 477, + 488, + 492, + 497, + 504, + 506, + 510, + 513, + 515, + 523, + 526, + 557, + 567, + 577, + 580, + 581, + 594, + 597, + 605, + 607, + 608, + 610, + 626, + 628, + 653, + 654, + 658, + 659 + ], + [ + 242, + 243, + 263, + 267, + 274, + 281, + 282, + 288, + 290, + 292, + 293, + 301, + 305, + 308, + 313, + 316, + 320, + 325, + 326, + 327, + 328, + 331, + 334, + 337, + 338, + 339, + 344, + 345, + 346, + 349, + 359, + 368, + 370, + 373, + 374, + 375, + 377, + 378, + 380, + 381, + 382, + 384, + 386, + 388, + 391, + 392, + 396, + 398, + 399, + 401, + 407, + 411, + 413, + 414, + 416, + 421, + 426, + 433, + 435, + 438, + 441, + 444, + 455, + 456, + 460, + 461, + 463, + 464, + 466, + 467, + 468, + 471, + 477, + 488, + 492, + 497, + 504, + 506, + 510, + 513, + 515, + 523, + 526, + 528, + 557, + 567, + 577, + 580, + 581, + 594, + 597, + 600, + 605, + 625, + 628, + 653, + 654, + 658, + 659 + ], + [ + 241, + 243, + 244, + 246, + 247, + 252, + 254, + 255, + 256, + 257, + 261, + 262, + 263, + 264, + 274, + 275, + 276, + 278, + 284, + 293, + 294, + 297, + 298, + 301, + 302, + 303, + 305, + 306, + 310, + 331, + 335, + 340, + 345, + 347, + 349, + 356, + 357, + 358, + 361, + 373, + 374, + 375, + 376, + 378, + 380, + 383, + 391, + 396, + 399, + 401, + 405, + 409, + 419, + 421, + 429, + 430, + 432, + 439, + 440, + 441, + 442, + 446, + 447, + 458, + 461, + 463, + 464, + 478, + 487, + 492, + 496, + 498, + 511, + 513, + 514, + 516, + 523, + 532, + 534, + 547, + 548, + 549, + 552, + 557, + 558, + 569, + 580, + 581, + 582, + 603, + 610, + 620, + 622, + 625, + 627, + 652, + 657, + 659 + ], + [ + 242, + 243, + 250, + 251, + 253, + 255, + 263, + 267, + 269, + 274, + 279, + 281, + 286, + 290, + 297, + 303, + 308, + 316, + 318, + 320, + 321, + 328, + 330, + 332, + 333, + 338, + 342, + 344, + 346, + 347, + 349, + 354, + 356, + 357, + 358, + 371, + 376, + 378, + 379, + 381, + 382, + 386, + 391, + 395, + 397, + 401, + 411, + 412, + 413, + 414, + 417, + 419, + 421, + 425, + 427, + 429, + 430, + 433, + 439, + 442, + 444, + 449, + 450, + 453, + 458, + 463, + 465, + 466, + 467, + 468, + 480, + 502, + 504, + 510, + 513, + 523, + 526, + 528, + 530, + 531, + 532, + 538, + 540, + 550, + 552, + 556, + 558, + 568, + 570, + 574, + 581, + 582, + 596, + 600, + 602, + 606, + 610, + 613, + 621, + 627, + 638, + 639, + 651, + 653, + 654, + 659 + ], + [ + 247, + 261, + 265, + 276, + 278, + 281, + 284, + 286, + 288, + 293, + 294, + 295, + 297, + 298, + 302, + 303, + 305, + 308, + 309, + 313, + 314, + 318, + 321, + 325, + 333, + 334, + 337, + 339, + 347, + 349, + 353, + 370, + 373, + 376, + 378, + 382, + 384, + 386, + 391, + 392, + 397, + 404, + 407, + 412, + 421, + 425, + 429, + 430, + 432, + 440, + 442, + 444, + 446, + 447, + 453, + 458, + 482, + 484, + 488, + 489, + 492, + 502, + 506, + 513, + 516, + 547, + 548, + 549, + 550, + 567, + 581, + 596, + 597, + 602, + 603, + 620, + 621, + 638, + 639, + 651, + 657 + ], + [ + 241, + 258, + 261, + 264, + 265, + 270, + 276, + 278, + 281, + 284, + 286, + 288, + 293, + 294, + 295, + 297, + 298, + 299, + 302, + 303, + 305, + 308, + 309, + 313, + 314, + 318, + 321, + 325, + 333, + 334, + 337, + 339, + 340, + 347, + 349, + 353, + 370, + 373, + 376, + 378, + 382, + 384, + 386, + 391, + 392, + 397, + 404, + 407, + 412, + 421, + 425, + 429, + 430, + 432, + 440, + 442, + 444, + 446, + 447, + 453, + 458, + 483, + 488, + 489, + 492, + 500, + 506, + 513, + 516, + 547, + 548, + 549, + 550, + 567, + 581, + 596, + 597, + 602, + 603, + 620, + 621, + 638, + 639, + 651, + 657 + ], + [ + 242, + 243, + 250, + 251, + 253, + 255, + 274, + 279, + 281, + 286, + 290, + 295, + 308, + 314, + 326, + 327, + 338, + 339, + 342, + 344, + 345, + 346, + 349, + 353, + 354, + 355, + 358, + 360, + 361, + 364, + 366, + 368, + 370, + 375, + 376, + 378, + 379, + 382, + 383, + 396, + 398, + 404, + 416, + 417, + 419, + 421, + 423, + 426, + 427, + 432, + 438, + 446, + 447, + 457, + 460, + 463, + 475, + 476, + 480, + 482, + 489, + 502, + 504, + 510, + 513, + 530, + 531, + 532, + 540, + 545, + 547, + 548, + 549, + 552, + 553, + 557, + 558, + 568, + 570, + 571, + 577, + 580, + 581, + 582, + 594, + 603, + 605, + 607, + 608, + 610, + 613, + 620, + 625, + 627, + 628, + 657, + 658 + ], + [ + 267, + 274, + 281, + 282, + 288, + 290, + 293, + 298, + 306, + 310, + 313, + 316, + 322, + 325, + 328, + 329, + 330, + 331, + 332, + 333, + 335, + 337, + 339, + 343, + 353, + 357, + 359, + 361, + 363, + 373, + 374, + 375, + 378, + 391, + 392, + 399, + 401, + 402, + 404, + 405, + 413, + 416, + 418, + 421, + 426, + 428, + 430, + 433, + 435, + 438, + 441, + 444, + 455, + 460, + 461, + 463, + 468, + 473, + 478, + 479, + 486, + 488, + 491, + 506, + 507, + 509, + 513, + 525, + 542, + 543, + 557, + 560, + 561, + 567, + 579, + 588, + 590, + 646, + 658 + ], + [ + 246, + 247, + 261, + 264, + 265, + 270, + 276, + 278, + 281, + 284, + 286, + 288, + 293, + 294, + 295, + 297, + 298, + 299, + 302, + 303, + 305, + 308, + 309, + 313, + 314, + 318, + 321, + 325, + 333, + 334, + 337, + 339, + 347, + 349, + 353, + 356, + 370, + 373, + 376, + 378, + 382, + 384, + 386, + 391, + 392, + 397, + 404, + 407, + 412, + 421, + 425, + 429, + 430, + 432, + 440, + 442, + 444, + 446, + 447, + 453, + 458, + 483, + 484, + 485, + 488, + 489, + 492, + 498, + 500, + 503, + 506, + 513, + 516, + 547, + 548, + 549, + 550, + 567, + 581, + 596, + 597, + 602, + 603, + 620, + 621, + 638, + 639, + 651, + 657 + ], + [ + 240, + 247, + 251, + 252, + 258, + 263, + 265, + 267, + 272, + 274, + 275, + 282, + 284, + 285, + 288, + 294, + 295, + 308, + 309, + 310, + 314, + 321, + 328, + 334, + 335, + 339, + 344, + 347, + 353, + 354, + 355, + 357, + 360, + 361, + 363, + 364, + 370, + 375, + 376, + 377, + 380, + 385, + 386, + 395, + 400, + 409, + 411, + 412, + 413, + 419, + 421, + 423, + 427, + 435, + 439, + 441, + 447, + 453, + 463, + 466, + 467, + 468, + 487, + 492, + 502, + 503, + 513, + 514, + 516, + 529, + 530, + 531, + 532, + 533, + 545, + 549, + 550, + 552, + 567, + 568, + 569, + 581, + 595, + 601, + 602, + 613, + 616, + 621, + 631, + 651, + 658 + ], + [ + 257, + 274, + 281, + 282, + 288, + 290, + 293, + 298, + 306, + 310, + 313, + 316, + 322, + 325, + 328, + 330, + 331, + 332, + 333, + 335, + 337, + 339, + 343, + 353, + 357, + 359, + 361, + 363, + 373, + 374, + 375, + 378, + 391, + 392, + 398, + 399, + 401, + 402, + 404, + 405, + 413, + 416, + 418, + 421, + 426, + 428, + 430, + 433, + 435, + 438, + 441, + 444, + 455, + 460, + 461, + 463, + 466, + 467, + 468, + 469, + 473, + 478, + 486, + 488, + 491, + 506, + 507, + 509, + 513, + 525, + 542, + 543, + 557, + 560, + 561, + 567, + 579, + 588, + 592, + 644, + 658 + ], + [ + 246, + 252, + 253, + 261, + 264, + 272, + 275, + 281, + 284, + 285, + 290, + 293, + 294, + 295, + 305, + 309, + 313, + 325, + 331, + 333, + 337, + 344, + 345, + 349, + 352, + 354, + 368, + 370, + 371, + 373, + 377, + 380, + 381, + 382, + 383, + 384, + 386, + 392, + 396, + 397, + 398, + 400, + 401, + 404, + 407, + 412, + 416, + 421, + 425, + 426, + 427, + 433, + 438, + 439, + 444, + 447, + 453, + 455, + 461, + 485, + 487, + 488, + 498, + 502, + 506, + 514, + 516, + 529, + 530, + 531, + 532, + 533, + 545, + 549, + 550, + 552, + 557, + 568, + 569, + 595, + 597, + 601, + 602, + 613, + 616, + 621, + 631, + 651 + ], + [ + 250, + 251, + 253, + 257, + 274, + 275, + 279, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 299, + 302, + 305, + 306, + 309, + 314, + 316, + 318, + 322, + 327, + 330, + 337, + 339, + 342, + 354, + 355, + 361, + 363, + 364, + 367, + 371, + 373, + 376, + 377, + 381, + 383, + 399, + 402, + 407, + 414, + 418, + 419, + 427, + 428, + 433, + 437, + 438, + 443, + 444, + 446, + 447, + 449, + 458, + 459, + 460, + 461, + 463, + 473, + 478, + 480, + 486, + 502, + 506, + 509, + 511, + 518, + 525, + 530, + 531, + 533, + 537, + 540, + 542, + 545, + 547, + 548, + 552, + 554, + 561, + 568, + 570, + 588, + 592, + 596, + 601, + 603, + 612, + 613, + 620, + 622, + 623, + 630, + 631, + 638, + 639, + 652, + 657, + 658 + ], + [ + 250, + 251, + 253, + 257, + 267, + 281, + 283, + 285, + 286, + 287, + 288, + 294, + 295, + 298, + 303, + 308, + 310, + 327, + 328, + 331, + 332, + 334, + 335, + 337, + 339, + 342, + 345, + 353, + 354, + 356, + 357, + 360, + 367, + 368, + 370, + 373, + 375, + 376, + 377, + 386, + 391, + 395, + 396, + 399, + 401, + 405, + 412, + 413, + 414, + 416, + 419, + 425, + 426, + 427, + 428, + 429, + 437, + 438, + 439, + 440, + 442, + 443, + 444, + 449, + 453, + 455, + 459, + 460, + 461, + 467, + 468, + 479, + 480, + 486, + 502, + 506, + 507, + 509, + 511, + 519, + 530, + 531, + 533, + 540, + 543, + 545, + 549, + 550, + 552, + 557, + 560, + 568, + 570, + 572, + 579, + 601, + 602, + 613, + 617, + 618, + 621, + 622, + 631, + 636, + 646, + 651, + 652 + ], + [ + 241, + 246, + 247, + 252, + 260, + 261, + 263, + 267, + 272, + 274, + 275, + 276, + 278, + 282, + 285, + 297, + 299, + 302, + 306, + 310, + 321, + 322, + 323, + 333, + 334, + 335, + 354, + 355, + 357, + 358, + 361, + 364, + 378, + 379, + 381, + 391, + 392, + 397, + 399, + 404, + 405, + 407, + 409, + 416, + 425, + 426, + 429, + 432, + 438, + 442, + 444, + 446, + 449, + 458, + 459, + 460, + 467, + 468, + 485, + 487, + 488, + 496, + 498, + 506, + 509, + 511, + 512, + 513, + 540, + 548, + 549, + 558, + 568, + 569, + 570, + 575, + 581, + 594, + 597, + 608, + 616, + 620, + 622, + 639, + 652, + 658, + 659 + ], + [ + 251, + 252, + 253, + 255, + 267, + 272, + 281, + 283, + 287, + 288, + 293, + 297, + 298, + 303, + 305, + 310, + 316, + 325, + 327, + 333, + 343, + 344, + 345, + 352, + 353, + 357, + 360, + 361, + 363, + 366, + 367, + 368, + 373, + 376, + 380, + 381, + 382, + 383, + 384, + 388, + 398, + 400, + 401, + 404, + 405, + 409, + 414, + 419, + 425, + 430, + 432, + 433, + 437, + 438, + 439, + 440, + 442, + 443, + 449, + 453, + 457, + 458, + 459, + 460, + 461, + 468, + 474, + 481, + 483, + 488, + 489, + 490, + 492, + 501, + 502, + 505, + 507, + 512, + 518, + 528, + 529, + 530, + 532, + 549, + 554, + 558, + 567, + 570, + 572, + 575, + 582, + 589, + 591, + 595, + 616, + 621, + 622, + 633, + 641, + 657 + ], + [ + 263, + 267, + 274, + 281, + 282, + 287, + 288, + 290, + 293, + 305, + 306, + 316, + 318, + 322, + 332, + 333, + 335, + 339, + 343, + 345, + 347, + 349, + 354, + 355, + 366, + 368, + 370, + 376, + 377, + 381, + 382, + 384, + 386, + 388, + 392, + 396, + 398, + 404, + 406, + 412, + 413, + 416, + 420, + 428, + 433, + 435, + 441, + 449, + 450, + 455, + 461, + 463, + 466, + 467, + 468, + 492, + 495, + 507, + 519, + 520, + 547, + 550, + 581, + 597, + 602, + 603, + 651 + ], + [ + 243, + 251, + 252, + 253, + 275, + 286, + 287, + 290, + 293, + 297, + 298, + 299, + 306, + 309, + 310, + 328, + 333, + 335, + 339, + 344, + 345, + 354, + 357, + 358, + 359, + 360, + 370, + 371, + 375, + 378, + 379, + 381, + 383, + 384, + 386, + 392, + 395, + 396, + 397, + 399, + 404, + 405, + 406, + 409, + 412, + 413, + 419, + 421, + 425, + 426, + 429, + 430, + 432, + 433, + 435, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 450, + 453, + 459, + 463, + 467, + 468, + 469, + 473, + 474, + 475, + 477, + 481, + 483, + 487, + 490, + 492, + 496, + 502, + 504, + 505, + 513, + 518, + 523, + 532, + 547, + 550, + 552, + 554, + 558, + 567, + 568, + 570, + 580, + 591, + 597, + 602, + 603, + 604, + 610, + 616, + 621, + 625, + 627, + 639, + 641, + 657, + 658, + 659 + ], + [ + 243, + 251, + 252, + 253, + 255, + 269, + 272, + 283, + 284, + 286, + 295, + 297, + 301, + 305, + 306, + 308, + 309, + 310, + 313, + 321, + 331, + 332, + 334, + 337, + 343, + 345, + 352, + 356, + 357, + 359, + 363, + 368, + 370, + 371, + 375, + 376, + 377, + 381, + 386, + 388, + 391, + 392, + 395, + 400, + 401, + 402, + 405, + 406, + 407, + 409, + 412, + 416, + 421, + 426, + 429, + 433, + 437, + 441, + 442, + 444, + 447, + 453, + 463, + 465, + 477, + 481, + 483, + 496, + 502, + 504, + 506, + 507, + 511, + 514, + 523, + 529, + 531, + 532, + 534, + 537, + 538, + 540, + 545, + 547, + 550, + 552, + 556, + 557, + 558, + 567, + 570, + 573, + 575, + 580, + 582, + 595, + 602, + 603, + 606, + 610, + 613, + 621, + 623, + 625, + 627, + 629, + 630, + 639, + 643, + 659 + ], + [ + 255, + 263, + 267, + 274, + 282, + 288, + 290, + 293, + 298, + 306, + 310, + 314, + 316, + 318, + 320, + 321, + 322, + 331, + 332, + 333, + 335, + 337, + 347, + 349, + 352, + 355, + 358, + 364, + 367, + 371, + 375, + 376, + 378, + 379, + 382, + 383, + 384, + 388, + 404, + 405, + 409, + 412, + 413, + 416, + 419, + 424, + 432, + 433, + 435, + 438, + 441, + 444, + 450, + 455, + 458, + 461, + 463, + 466, + 467, + 468, + 474, + 488, + 490, + 492, + 505, + 506, + 507, + 508, + 511, + 513, + 514, + 530, + 531, + 540, + 545, + 557, + 576, + 582, + 587, + 596, + 597, + 604, + 637, + 652, + 657, + 658 + ], + [ + 263, + 267, + 274, + 279, + 282, + 290, + 293, + 299, + 305, + 306, + 310, + 313, + 316, + 321, + 322, + 325, + 327, + 328, + 335, + 337, + 344, + 345, + 349, + 355, + 358, + 367, + 368, + 375, + 376, + 378, + 379, + 380, + 381, + 382, + 396, + 400, + 401, + 402, + 406, + 409, + 414, + 421, + 426, + 427, + 429, + 431, + 433, + 435, + 438, + 441, + 444, + 455, + 461, + 463, + 466, + 467, + 468, + 487, + 488, + 492, + 495, + 496, + 506, + 507, + 513, + 514, + 529, + 532, + 537, + 538, + 545, + 557, + 567, + 568, + 574, + 575, + 581, + 595, + 597 + ], + [ + 246, + 247, + 263, + 267, + 270, + 274, + 279, + 282, + 284, + 286, + 290, + 293, + 294, + 300, + 310, + 316, + 326, + 328, + 337, + 343, + 344, + 345, + 352, + 353, + 355, + 357, + 358, + 361, + 368, + 373, + 374, + 378, + 380, + 381, + 388, + 392, + 396, + 397, + 398, + 399, + 404, + 405, + 407, + 409, + 413, + 414, + 416, + 419, + 421, + 430, + 433, + 437, + 439, + 440, + 441, + 444, + 449, + 453, + 455, + 457, + 461, + 466, + 467, + 468, + 483, + 487, + 488, + 496, + 498, + 501, + 511, + 512, + 516, + 529, + 530, + 531, + 532, + 534, + 537, + 548, + 549, + 558, + 563, + 568, + 572, + 589, + 595, + 596, + 598, + 621, + 630, + 633, + 638, + 639, + 643, + 657, + 658 + ], + [ + 243, + 255, + 267, + 269, + 274, + 275, + 279, + 282, + 286, + 290, + 295, + 298, + 299, + 301, + 303, + 308, + 310, + 314, + 316, + 321, + 322, + 325, + 327, + 330, + 333, + 334, + 343, + 344, + 347, + 355, + 358, + 359, + 360, + 361, + 366, + 368, + 371, + 373, + 375, + 376, + 382, + 388, + 391, + 395, + 396, + 398, + 404, + 406, + 407, + 409, + 413, + 414, + 416, + 419, + 420, + 425, + 427, + 432, + 433, + 440, + 441, + 443, + 449, + 453, + 455, + 459, + 465, + 468, + 477, + 482, + 487, + 489, + 501, + 504, + 507, + 520, + 523, + 531, + 532, + 534, + 538, + 547, + 552, + 555, + 557, + 558, + 569, + 574, + 580, + 581, + 582, + 597, + 603, + 606, + 610, + 613, + 616, + 617, + 621, + 622, + 625, + 627, + 629, + 636, + 639, + 645, + 652, + 658, + 659 + ], + [ + 244, + 251, + 252, + 253, + 263, + 281, + 282, + 283, + 285, + 286, + 288, + 293, + 294, + 295, + 297, + 306, + 313, + 314, + 316, + 318, + 322, + 327, + 330, + 331, + 333, + 337, + 339, + 343, + 344, + 345, + 347, + 349, + 352, + 354, + 359, + 361, + 367, + 370, + 374, + 376, + 379, + 384, + 386, + 388, + 391, + 395, + 398, + 399, + 401, + 402, + 404, + 412, + 413, + 414, + 416, + 419, + 421, + 425, + 427, + 437, + 438, + 439, + 440, + 442, + 449, + 450, + 451, + 453, + 455, + 460, + 461, + 463, + 464, + 465, + 466, + 468, + 469, + 477, + 481, + 482, + 483, + 487, + 496, + 502, + 504, + 506, + 530, + 532, + 533, + 535, + 536, + 540, + 547, + 549, + 550, + 552, + 553, + 557, + 568, + 570, + 575, + 589, + 596, + 601, + 602, + 603, + 611, + 616, + 618, + 621, + 622, + 624, + 631, + 638, + 652 + ], + [ + 244, + 272, + 279, + 281, + 285, + 286, + 287, + 297, + 298, + 299, + 302, + 308, + 313, + 314, + 318, + 321, + 327, + 328, + 332, + 334, + 335, + 337, + 343, + 353, + 354, + 355, + 357, + 359, + 364, + 366, + 371, + 373, + 374, + 377, + 378, + 381, + 383, + 384, + 392, + 396, + 399, + 400, + 405, + 407, + 413, + 414, + 425, + 426, + 428, + 429, + 430, + 435, + 438, + 440, + 441, + 442, + 443, + 446, + 458, + 459, + 460, + 464, + 465, + 467, + 468, + 469, + 477, + 482, + 487, + 488, + 489, + 492, + 496, + 501, + 504, + 506, + 511, + 513, + 517, + 529, + 530, + 532, + 533, + 547, + 548, + 552, + 553, + 554, + 568, + 569, + 571, + 591, + 595, + 601, + 603, + 611, + 612, + 620, + 624, + 631, + 639, + 657 + ], + [ + 245, + 263, + 267, + 274, + 282, + 288, + 290, + 298, + 303, + 306, + 310, + 314, + 316, + 318, + 320, + 321, + 322, + 331, + 332, + 333, + 335, + 337, + 347, + 349, + 352, + 355, + 358, + 367, + 371, + 375, + 376, + 378, + 379, + 382, + 383, + 384, + 388, + 404, + 405, + 409, + 412, + 413, + 416, + 419, + 424, + 435, + 438, + 441, + 442, + 444, + 450, + 455, + 458, + 459, + 461, + 463, + 466, + 467, + 468, + 488, + 490, + 492, + 505, + 506, + 507, + 508, + 511, + 513, + 514, + 530, + 531, + 540, + 545, + 557, + 576, + 582, + 587, + 596, + 597, + 604, + 614, + 615, + 638, + 639, + 640, + 652, + 657, + 658 + ], + [ + 242, + 243, + 251, + 252, + 267, + 269, + 274, + 275, + 277, + 281, + 283, + 285, + 288, + 297, + 303, + 308, + 309, + 313, + 321, + 325, + 331, + 332, + 334, + 339, + 342, + 345, + 349, + 352, + 353, + 354, + 356, + 361, + 363, + 364, + 366, + 368, + 371, + 374, + 376, + 379, + 380, + 391, + 392, + 395, + 396, + 397, + 401, + 411, + 419, + 428, + 430, + 432, + 437, + 438, + 440, + 444, + 447, + 449, + 455, + 457, + 459, + 464, + 467, + 469, + 473, + 475, + 483, + 488, + 490, + 501, + 513, + 523, + 528, + 529, + 530, + 531, + 537, + 540, + 548, + 567, + 570, + 575, + 582, + 595, + 596, + 597, + 598, + 604, + 616, + 620, + 622, + 627, + 633, + 634, + 638, + 639, + 643, + 659 + ], + [ + 263, + 267, + 281, + 282, + 288, + 290, + 293, + 305, + 306, + 316, + 318, + 322, + 332, + 333, + 335, + 343, + 345, + 347, + 349, + 354, + 355, + 366, + 368, + 369, + 370, + 376, + 377, + 381, + 382, + 384, + 386, + 388, + 392, + 396, + 398, + 404, + 406, + 412, + 413, + 416, + 428, + 433, + 435, + 441, + 449, + 450, + 455, + 460, + 461, + 463, + 466, + 467, + 468, + 482, + 492, + 495, + 507, + 518, + 547, + 550, + 553, + 554, + 581, + 597, + 602, + 603, + 651 + ], + [ + 263, + 267, + 274, + 282, + 283, + 288, + 290, + 293, + 299, + 305, + 306, + 309, + 310, + 313, + 316, + 321, + 322, + 325, + 327, + 328, + 330, + 335, + 337, + 344, + 345, + 349, + 355, + 358, + 367, + 368, + 375, + 376, + 378, + 379, + 380, + 381, + 382, + 396, + 400, + 401, + 402, + 406, + 414, + 421, + 426, + 427, + 429, + 433, + 435, + 438, + 440, + 441, + 444, + 451, + 455, + 461, + 462, + 463, + 466, + 467, + 468, + 487, + 488, + 492, + 495, + 496, + 506, + 507, + 513, + 514, + 529, + 532, + 535, + 557, + 567, + 568, + 572, + 575, + 581, + 595, + 597 + ], + [ + 251, + 252, + 269, + 272, + 274, + 275, + 281, + 283, + 293, + 297, + 301, + 303, + 305, + 310, + 314, + 318, + 322, + 326, + 337, + 339, + 342, + 345, + 352, + 354, + 356, + 357, + 358, + 359, + 360, + 363, + 364, + 366, + 377, + 378, + 379, + 381, + 391, + 392, + 396, + 397, + 398, + 399, + 405, + 406, + 407, + 409, + 413, + 421, + 428, + 429, + 430, + 432, + 433, + 437, + 439, + 440, + 441, + 442, + 446, + 456, + 459, + 460, + 461, + 463, + 464, + 477, + 482, + 483, + 490, + 496, + 501, + 506, + 508, + 511, + 512, + 513, + 534, + 537, + 540, + 545, + 563, + 564, + 567, + 568, + 569, + 570, + 580, + 597, + 610, + 613, + 619, + 625, + 632, + 643 + ], + [ + 251, + 252, + 253, + 263, + 272, + 282, + 285, + 286, + 287, + 298, + 299, + 301, + 308, + 309, + 310, + 318, + 320, + 331, + 334, + 335, + 337, + 339, + 345, + 347, + 352, + 355, + 356, + 359, + 360, + 361, + 363, + 364, + 366, + 368, + 370, + 371, + 374, + 375, + 376, + 377, + 379, + 382, + 384, + 386, + 388, + 395, + 396, + 400, + 406, + 407, + 409, + 411, + 412, + 419, + 427, + 428, + 429, + 430, + 433, + 440, + 441, + 443, + 447, + 450, + 453, + 457, + 459, + 463, + 464, + 466, + 467, + 477, + 481, + 483, + 487, + 488, + 489, + 490, + 502, + 504, + 505, + 506, + 511, + 514, + 519, + 529, + 532, + 533, + 534, + 540, + 547, + 549, + 550, + 552, + 557, + 570, + 576, + 587, + 595, + 601, + 602, + 603, + 613, + 614, + 621, + 622, + 631, + 645 + ], + [ + 255, + 263, + 267, + 274, + 275, + 281, + 285, + 286, + 293, + 297, + 306, + 309, + 316, + 320, + 330, + 332, + 333, + 334, + 335, + 344, + 347, + 354, + 356, + 371, + 374, + 376, + 378, + 380, + 383, + 384, + 388, + 392, + 395, + 400, + 401, + 402, + 418, + 423, + 425, + 426, + 428, + 429, + 432, + 433, + 438, + 444, + 449, + 453, + 455, + 457, + 461, + 464, + 467, + 468, + 471, + 473, + 475, + 476, + 492, + 506, + 511, + 513, + 529, + 532, + 542, + 547, + 549, + 552, + 561, + 568, + 569, + 580, + 595, + 603, + 609, + 610, + 621, + 622, + 625, + 647, + 652, + 654 + ], + [ + 272, + 275, + 279, + 281, + 282, + 290, + 299, + 301, + 309, + 310, + 322, + 327, + 328, + 331, + 333, + 335, + 337, + 339, + 346, + 349, + 352, + 353, + 355, + 358, + 366, + 370, + 374, + 375, + 379, + 382, + 386, + 392, + 398, + 399, + 405, + 406, + 407, + 409, + 416, + 417, + 419, + 425, + 427, + 430, + 438, + 439, + 440, + 441, + 444, + 446, + 453, + 457, + 460, + 461, + 466, + 496, + 508, + 511, + 514, + 530, + 531, + 534, + 545, + 547, + 548, + 549, + 550, + 567, + 575, + 596, + 597, + 600, + 602, + 604, + 613, + 616, + 620, + 621, + 638, + 639, + 652, + 657, + 658 + ], + [ + 255, + 257, + 263, + 272, + 281, + 286, + 288, + 298, + 299, + 303, + 306, + 310, + 314, + 316, + 320, + 327, + 328, + 332, + 333, + 334, + 343, + 347, + 360, + 363, + 368, + 371, + 373, + 374, + 375, + 377, + 379, + 380, + 382, + 384, + 388, + 395, + 397, + 398, + 400, + 401, + 404, + 407, + 409, + 413, + 414, + 425, + 426, + 430, + 433, + 435, + 440, + 444, + 446, + 453, + 455, + 457, + 459, + 461, + 464, + 466, + 469, + 471, + 473, + 475, + 476, + 478, + 488, + 506, + 507, + 509, + 513, + 514, + 526, + 532, + 534, + 540, + 547, + 552, + 568, + 570, + 575, + 580, + 581, + 582, + 597, + 599, + 603, + 609, + 610, + 616, + 625, + 639, + 654, + 658 + ], + [ + 269, + 272, + 275, + 288, + 290, + 301, + 303, + 305, + 308, + 309, + 310, + 313, + 314, + 318, + 325, + 330, + 333, + 334, + 339, + 343, + 345, + 347, + 349, + 353, + 354, + 356, + 360, + 363, + 368, + 370, + 371, + 375, + 376, + 377, + 381, + 382, + 383, + 386, + 391, + 392, + 395, + 396, + 397, + 404, + 407, + 412, + 418, + 421, + 425, + 428, + 429, + 430, + 432, + 435, + 438, + 439, + 440, + 441, + 442, + 444, + 446, + 453, + 455, + 457, + 459, + 461, + 482, + 488, + 492, + 495, + 506, + 507, + 514, + 524, + 530, + 531, + 543, + 544, + 545, + 547, + 548, + 549, + 550, + 579, + 580, + 581, + 596, + 602, + 603, + 613, + 616, + 620, + 621, + 638, + 639, + 651, + 657 + ], + [ + 255, + 257, + 263, + 272, + 274, + 285, + 286, + 290, + 293, + 295, + 297, + 299, + 303, + 305, + 306, + 308, + 310, + 316, + 318, + 320, + 321, + 327, + 328, + 331, + 335, + 344, + 349, + 352, + 353, + 354, + 356, + 363, + 368, + 370, + 371, + 373, + 374, + 376, + 379, + 386, + 388, + 391, + 392, + 398, + 400, + 409, + 412, + 413, + 414, + 421, + 429, + 432, + 435, + 439, + 444, + 446, + 449, + 453, + 456, + 459, + 460, + 464, + 466, + 469, + 471, + 473, + 475, + 476, + 478, + 482, + 488, + 489, + 492, + 495, + 506, + 507, + 512, + 514, + 526, + 529, + 540, + 548, + 549, + 550, + 552, + 580, + 587, + 597, + 599, + 602, + 609, + 610, + 616, + 620, + 621, + 625, + 639, + 651, + 654, + 655, + 656, + 657 + ], + [ + 256, + 257, + 267, + 282, + 286, + 293, + 298, + 299, + 308, + 309, + 310, + 330, + 332, + 333, + 334, + 344, + 347, + 349, + 352, + 354, + 355, + 356, + 357, + 363, + 367, + 371, + 373, + 374, + 375, + 378, + 380, + 383, + 388, + 391, + 392, + 395, + 396, + 397, + 399, + 400, + 402, + 409, + 411, + 414, + 416, + 417, + 419, + 423, + 427, + 433, + 438, + 439, + 441, + 449, + 455, + 467, + 468, + 473, + 478, + 482, + 495, + 496, + 506, + 513, + 514, + 528, + 529, + 530, + 532, + 534, + 540, + 543, + 547, + 552, + 560, + 570, + 580, + 581, + 595, + 603, + 642, + 653, + 658 + ], + [ + 262, + 269, + 279, + 281, + 285, + 290, + 291, + 293, + 295, + 297, + 298, + 299, + 308, + 309, + 313, + 314, + 318, + 321, + 325, + 326, + 327, + 332, + 334, + 335, + 337, + 343, + 347, + 356, + 358, + 360, + 363, + 364, + 366, + 367, + 370, + 371, + 376, + 378, + 379, + 383, + 386, + 391, + 395, + 397, + 398, + 404, + 405, + 407, + 412, + 429, + 430, + 432, + 433, + 435, + 439, + 440, + 441, + 444, + 449, + 455, + 456, + 457, + 461, + 482, + 487, + 488, + 489, + 492, + 506, + 511, + 513, + 522, + 547, + 550, + 561, + 562, + 567, + 596, + 597, + 602, + 603, + 638, + 639, + 651, + 657 + ], + [ + 268, + 269, + 275, + 279, + 286, + 288, + 290, + 297, + 299, + 303, + 305, + 308, + 310, + 313, + 314, + 321, + 322, + 325, + 327, + 330, + 331, + 334, + 335, + 339, + 347, + 355, + 363, + 367, + 370, + 371, + 374, + 375, + 376, + 378, + 383, + 386, + 388, + 391, + 392, + 399, + 404, + 405, + 409, + 413, + 416, + 417, + 419, + 427, + 428, + 429, + 435, + 438, + 439, + 440, + 442, + 455, + 459, + 460, + 461, + 463, + 466, + 482, + 488, + 489, + 490, + 492, + 505, + 508, + 511, + 513, + 528, + 530, + 531, + 533, + 534, + 545, + 547, + 550, + 552, + 557, + 564, + 569, + 581, + 600, + 603, + 613, + 616, + 622, + 631, + 650, + 652 + ], + [ + 269, + 272, + 275, + 288, + 290, + 301, + 303, + 305, + 308, + 309, + 311, + 313, + 314, + 318, + 325, + 333, + 334, + 339, + 343, + 345, + 347, + 349, + 353, + 354, + 356, + 360, + 368, + 370, + 371, + 375, + 376, + 377, + 381, + 382, + 383, + 386, + 387, + 391, + 392, + 395, + 396, + 397, + 402, + 404, + 407, + 412, + 418, + 421, + 425, + 428, + 429, + 432, + 435, + 438, + 439, + 440, + 441, + 442, + 444, + 446, + 453, + 455, + 457, + 459, + 461, + 482, + 488, + 492, + 495, + 506, + 507, + 514, + 530, + 531, + 541, + 542, + 545, + 547, + 548, + 549, + 550, + 581, + 596, + 602, + 603, + 613, + 616, + 620, + 621, + 638, + 639, + 651, + 657 + ], + [ + 251, + 252, + 257, + 274, + 275, + 281, + 286, + 288, + 293, + 297, + 299, + 305, + 308, + 313, + 316, + 318, + 322, + 326, + 328, + 331, + 332, + 333, + 334, + 335, + 342, + 345, + 352, + 353, + 354, + 355, + 356, + 358, + 359, + 373, + 375, + 384, + 388, + 391, + 402, + 405, + 406, + 407, + 408, + 409, + 411, + 414, + 418, + 425, + 426, + 428, + 430, + 435, + 439, + 440, + 442, + 444, + 450, + 455, + 468, + 478, + 483, + 487, + 496, + 504, + 505, + 511, + 528, + 530, + 534, + 540, + 545, + 552, + 568, + 570, + 575, + 577, + 597, + 607, + 613, + 639, + 648, + 651, + 657 + ], + [ + 281, + 286, + 293, + 298, + 299, + 303, + 305, + 306, + 313, + 318, + 321, + 322, + 323, + 325, + 328, + 334, + 337, + 344, + 349, + 356, + 358, + 360, + 363, + 373, + 375, + 377, + 378, + 379, + 380, + 381, + 382, + 384, + 395, + 399, + 400, + 405, + 411, + 413, + 416, + 419, + 423, + 426, + 427, + 430, + 435, + 438, + 439, + 440, + 441, + 449, + 459, + 460, + 463, + 466, + 482, + 489, + 496, + 509, + 511, + 512, + 513, + 514, + 529, + 530, + 531, + 532, + 533, + 540, + 545, + 547, + 549, + 552, + 558, + 570, + 575, + 581, + 594, + 595, + 596, + 601, + 603, + 608, + 613, + 622, + 631, + 638, + 652, + 657, + 659 + ], + [ + 256, + 257, + 263, + 269, + 272, + 274, + 275, + 279, + 281, + 282, + 286, + 295, + 298, + 299, + 308, + 316, + 321, + 327, + 328, + 331, + 332, + 345, + 349, + 353, + 355, + 356, + 360, + 364, + 367, + 370, + 371, + 376, + 377, + 378, + 379, + 380, + 386, + 388, + 391, + 396, + 398, + 399, + 409, + 412, + 413, + 415, + 419, + 426, + 427, + 428, + 438, + 440, + 441, + 444, + 446, + 449, + 456, + 457, + 466, + 473, + 478, + 487, + 492, + 496, + 506, + 511, + 513, + 523, + 530, + 531, + 532, + 533, + 534, + 543, + 545, + 548, + 549, + 550, + 552, + 557, + 558, + 567, + 569, + 579, + 582, + 594, + 601, + 602, + 613, + 616, + 620, + 631, + 642, + 651, + 657, + 658 + ], + [ + 242, + 243, + 257, + 267, + 272, + 275, + 279, + 285, + 286, + 290, + 295, + 299, + 301, + 308, + 309, + 313, + 314, + 318, + 321, + 322, + 325, + 326, + 327, + 331, + 334, + 335, + 339, + 344, + 345, + 347, + 349, + 353, + 354, + 360, + 371, + 375, + 376, + 378, + 379, + 384, + 388, + 395, + 396, + 398, + 400, + 401, + 404, + 406, + 411, + 416, + 421, + 429, + 430, + 435, + 438, + 439, + 440, + 441, + 446, + 453, + 460, + 467, + 468, + 469, + 473, + 475, + 477, + 478, + 482, + 488, + 489, + 492, + 513, + 514, + 523, + 529, + 548, + 552, + 558, + 564, + 567, + 568, + 569, + 577, + 581, + 582, + 595, + 607, + 620, + 621, + 627, + 648, + 649, + 650, + 651, + 657, + 658, + 659 + ], + [ + 242, + 243, + 263, + 267, + 274, + 275, + 282, + 285, + 286, + 288, + 295, + 297, + 299, + 306, + 309, + 310, + 311, + 314, + 316, + 318, + 326, + 333, + 335, + 337, + 339, + 343, + 347, + 352, + 354, + 355, + 358, + 361, + 367, + 368, + 373, + 375, + 377, + 380, + 381, + 383, + 388, + 391, + 392, + 395, + 396, + 398, + 402, + 414, + 417, + 423, + 425, + 426, + 432, + 438, + 449, + 457, + 461, + 463, + 467, + 468, + 473, + 475, + 477, + 506, + 507, + 511, + 514, + 523, + 525, + 531, + 532, + 533, + 540, + 545, + 547, + 549, + 552, + 558, + 561, + 567, + 568, + 570, + 578, + 581, + 582, + 596, + 601, + 603, + 605, + 607, + 613, + 616, + 622, + 627, + 631, + 638, + 639, + 647, + 652, + 658, + 659 + ], + [ + 269, + 279, + 281, + 285, + 290, + 293, + 295, + 297, + 299, + 308, + 309, + 313, + 314, + 318, + 321, + 325, + 326, + 332, + 334, + 335, + 337, + 343, + 356, + 358, + 360, + 363, + 364, + 366, + 367, + 370, + 371, + 376, + 378, + 379, + 383, + 386, + 391, + 395, + 397, + 398, + 407, + 412, + 414, + 415, + 424, + 425, + 429, + 430, + 432, + 433, + 435, + 439, + 440, + 441, + 444, + 455, + 456, + 457, + 461, + 482, + 487, + 488, + 489, + 492, + 506, + 511, + 513, + 522, + 523, + 524, + 547, + 550, + 559, + 567, + 596, + 597, + 602, + 603, + 638, + 639, + 651, + 657 + ], + [ + 246, + 247, + 257, + 270, + 274, + 281, + 290, + 298, + 299, + 305, + 306, + 307, + 308, + 309, + 314, + 316, + 321, + 322, + 332, + 333, + 334, + 335, + 337, + 343, + 353, + 354, + 358, + 363, + 373, + 374, + 376, + 377, + 378, + 384, + 388, + 398, + 399, + 405, + 407, + 411, + 414, + 416, + 421, + 423, + 425, + 430, + 438, + 440, + 441, + 444, + 460, + 461, + 463, + 466, + 468, + 478, + 482, + 487, + 488, + 492, + 495, + 496, + 498, + 500, + 507, + 509, + 511, + 513, + 530, + 531, + 557, + 570, + 575, + 594, + 595, + 597, + 598, + 608, + 638, + 639, + 657, + 658, + 659 + ], + [ + 246, + 247, + 251, + 252, + 264, + 269, + 279, + 282, + 293, + 299, + 309, + 310, + 313, + 325, + 327, + 328, + 332, + 333, + 339, + 342, + 344, + 345, + 347, + 354, + 355, + 358, + 359, + 368, + 372, + 373, + 374, + 375, + 380, + 381, + 388, + 396, + 400, + 401, + 405, + 407, + 409, + 413, + 416, + 419, + 425, + 426, + 427, + 430, + 433, + 440, + 441, + 455, + 460, + 482, + 483, + 487, + 489, + 490, + 496, + 498, + 511, + 529, + 530, + 531, + 532, + 534, + 567, + 568, + 595, + 596, + 638, + 639, + 657, + 658 + ], + [ + 246, + 247, + 248, + 255, + 263, + 264, + 272, + 274, + 279, + 286, + 290, + 306, + 308, + 313, + 316, + 318, + 321, + 327, + 328, + 330, + 332, + 334, + 335, + 337, + 344, + 347, + 354, + 356, + 359, + 367, + 371, + 376, + 377, + 379, + 380, + 382, + 383, + 384, + 386, + 388, + 392, + 393, + 395, + 396, + 397, + 400, + 404, + 406, + 407, + 411, + 413, + 419, + 424, + 425, + 426, + 430, + 432, + 433, + 438, + 442, + 446, + 450, + 453, + 457, + 460, + 463, + 466, + 468, + 469, + 471, + 473, + 475, + 477, + 482, + 496, + 498, + 504, + 507, + 511, + 515, + 531, + 540, + 545, + 552, + 557, + 567, + 568, + 570, + 580, + 596, + 598, + 610, + 613, + 625, + 638, + 651 + ], + [ + 263, + 267, + 269, + 274, + 275, + 285, + 295, + 298, + 305, + 306, + 308, + 314, + 316, + 318, + 321, + 322, + 328, + 330, + 332, + 334, + 345, + 353, + 355, + 356, + 357, + 360, + 361, + 364, + 366, + 367, + 368, + 370, + 371, + 381, + 383, + 384, + 386, + 390, + 391, + 393, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 405, + 406, + 407, + 412, + 424, + 425, + 426, + 427, + 430, + 439, + 450, + 456, + 457, + 466, + 467, + 468, + 482, + 489, + 507, + 547, + 548, + 549, + 550, + 557, + 596, + 598, + 602, + 603, + 620, + 621, + 638, + 639, + 651, + 657, + 658 + ], + [ + 246, + 247, + 264, + 269, + 272, + 279, + 286, + 288, + 293, + 297, + 301, + 308, + 313, + 318, + 322, + 327, + 330, + 331, + 333, + 334, + 343, + 345, + 349, + 353, + 356, + 358, + 359, + 366, + 367, + 370, + 373, + 378, + 382, + 384, + 386, + 391, + 392, + 399, + 400, + 402, + 405, + 406, + 407, + 408, + 409, + 411, + 413, + 418, + 421, + 425, + 426, + 429, + 430, + 441, + 442, + 444, + 446, + 453, + 455, + 457, + 482, + 487, + 492, + 498, + 504, + 507, + 508, + 511, + 513, + 529, + 530, + 532, + 534, + 540, + 547, + 548, + 549, + 550, + 552, + 557, + 570, + 580, + 595, + 597, + 602, + 603, + 610, + 616, + 620, + 621, + 625, + 639, + 657, + 658 + ], + [ + 252, + 253, + 261, + 275, + 281, + 286, + 290, + 297, + 305, + 310, + 313, + 318, + 320, + 321, + 322, + 328, + 331, + 335, + 337, + 342, + 344, + 345, + 350, + 352, + 356, + 357, + 368, + 373, + 375, + 380, + 381, + 391, + 392, + 396, + 399, + 401, + 404, + 409, + 411, + 414, + 416, + 425, + 427, + 429, + 433, + 438, + 439, + 442, + 444, + 450, + 460, + 461, + 485, + 489, + 498, + 504, + 508, + 509, + 514, + 530, + 533, + 545, + 552, + 557, + 566, + 567, + 569, + 575, + 576, + 580, + 596, + 597, + 601, + 610, + 613, + 622, + 625, + 631, + 638, + 651 + ], + [ + 263, + 267, + 269, + 274, + 285, + 286, + 290, + 295, + 297, + 306, + 308, + 309, + 310, + 313, + 314, + 322, + 325, + 326, + 331, + 334, + 335, + 343, + 345, + 346, + 348, + 352, + 355, + 356, + 360, + 363, + 366, + 368, + 370, + 375, + 381, + 382, + 391, + 395, + 396, + 397, + 398, + 402, + 406, + 407, + 413, + 416, + 428, + 429, + 430, + 432, + 434, + 438, + 440, + 450, + 456, + 457, + 461, + 463, + 466, + 467, + 468, + 482, + 489, + 507, + 546, + 547, + 548, + 549, + 550, + 552, + 558, + 563, + 583, + 585, + 597 + ], + [ + 248, + 252, + 253, + 255, + 261, + 267, + 269, + 274, + 275, + 281, + 295, + 303, + 305, + 306, + 313, + 316, + 318, + 325, + 326, + 328, + 331, + 342, + 345, + 346, + 354, + 356, + 359, + 363, + 366, + 367, + 368, + 370, + 371, + 373, + 376, + 377, + 378, + 379, + 382, + 384, + 391, + 392, + 395, + 400, + 402, + 404, + 411, + 412, + 413, + 414, + 416, + 427, + 432, + 434, + 438, + 442, + 444, + 449, + 453, + 455, + 456, + 459, + 461, + 467, + 469, + 471, + 473, + 475, + 477, + 485, + 486, + 489, + 496, + 497, + 498, + 504, + 506, + 509, + 513, + 514, + 515, + 529, + 531, + 532, + 545, + 546, + 547, + 548, + 549, + 550, + 557, + 563, + 568, + 569, + 580, + 581, + 585, + 595, + 596, + 597, + 602, + 610, + 613, + 616, + 621, + 622, + 625, + 638, + 639, + 651, + 652, + 657 + ], + [ + 251, + 253, + 261, + 269, + 272, + 274, + 279, + 281, + 282, + 290, + 298, + 301, + 305, + 308, + 314, + 318, + 321, + 327, + 328, + 333, + 334, + 335, + 337, + 349, + 352, + 353, + 354, + 355, + 358, + 363, + 366, + 367, + 370, + 374, + 378, + 381, + 382, + 384, + 386, + 388, + 396, + 398, + 400, + 401, + 412, + 413, + 416, + 425, + 426, + 427, + 429, + 430, + 435, + 438, + 439, + 440, + 441, + 444, + 446, + 448, + 449, + 453, + 457, + 460, + 461, + 483, + 485, + 487, + 489, + 490, + 492, + 496, + 498, + 506, + 507, + 513, + 531, + 534, + 539, + 547, + 548, + 549, + 550, + 568, + 569, + 581, + 595, + 597, + 602, + 603, + 620, + 621, + 651, + 658 + ], + [ + 263, + 267, + 269, + 274, + 282, + 285, + 286, + 290, + 295, + 297, + 306, + 308, + 309, + 310, + 313, + 314, + 322, + 325, + 326, + 331, + 334, + 335, + 345, + 346, + 349, + 352, + 355, + 356, + 360, + 363, + 366, + 368, + 370, + 375, + 381, + 388, + 391, + 395, + 396, + 397, + 398, + 402, + 403, + 406, + 407, + 413, + 416, + 419, + 428, + 429, + 430, + 432, + 438, + 440, + 450, + 456, + 457, + 461, + 463, + 466, + 467, + 468, + 482, + 489, + 507, + 546, + 549, + 552, + 558, + 563, + 581, + 583, + 584, + 585, + 586, + 597 + ], + [ + 263, + 267, + 269, + 274, + 275, + 285, + 295, + 298, + 305, + 306, + 308, + 314, + 316, + 318, + 321, + 322, + 328, + 330, + 332, + 334, + 345, + 353, + 355, + 356, + 357, + 360, + 361, + 364, + 366, + 367, + 368, + 370, + 371, + 381, + 383, + 384, + 386, + 391, + 395, + 396, + 397, + 398, + 400, + 401, + 405, + 406, + 407, + 412, + 424, + 425, + 426, + 427, + 430, + 439, + 450, + 456, + 457, + 466, + 467, + 468, + 482, + 489, + 507, + 547, + 548, + 549, + 550, + 557, + 596, + 598, + 602, + 603, + 620, + 621, + 638, + 639, + 651, + 657, + 658 + ], + [ + 247, + 250, + 251, + 252, + 261, + 263, + 265, + 267, + 269, + 274, + 282, + 288, + 293, + 298, + 310, + 328, + 331, + 337, + 347, + 349, + 352, + 353, + 354, + 356, + 358, + 361, + 364, + 368, + 371, + 373, + 375, + 382, + 383, + 388, + 391, + 392, + 395, + 396, + 398, + 399, + 404, + 405, + 407, + 409, + 413, + 414, + 416, + 419, + 425, + 430, + 433, + 435, + 440, + 444, + 449, + 455, + 460, + 466, + 467, + 468, + 482, + 485, + 488, + 492, + 496, + 498, + 503, + 509, + 511, + 514, + 531, + 533, + 565, + 567, + 568, + 570, + 575, + 581, + 596, + 597, + 619, + 638, + 639, + 657 + ], + [ + 246, + 247, + 251, + 252, + 264, + 269, + 279, + 282, + 293, + 299, + 309, + 310, + 313, + 325, + 327, + 328, + 332, + 333, + 339, + 342, + 344, + 345, + 347, + 354, + 355, + 358, + 368, + 374, + 375, + 376, + 380, + 381, + 388, + 396, + 400, + 401, + 405, + 407, + 409, + 413, + 416, + 419, + 425, + 426, + 427, + 430, + 433, + 440, + 441, + 455, + 460, + 482, + 483, + 487, + 488, + 490, + 496, + 498, + 506, + 509, + 511, + 529, + 530, + 531, + 532, + 534, + 568, + 595, + 596, + 638, + 639, + 657, + 658 + ], + [ + 242, + 243, + 263, + 269, + 274, + 285, + 288, + 293, + 295, + 305, + 308, + 310, + 314, + 316, + 318, + 321, + 322, + 334, + 335, + 339, + 344, + 349, + 350, + 354, + 355, + 356, + 358, + 359, + 361, + 366, + 371, + 373, + 375, + 376, + 380, + 384, + 391, + 397, + 400, + 405, + 406, + 407, + 409, + 411, + 413, + 419, + 423, + 425, + 426, + 427, + 429, + 433, + 438, + 439, + 441, + 455, + 457, + 460, + 461, + 463, + 466, + 468, + 469, + 473, + 475, + 477, + 482, + 489, + 492, + 496, + 504, + 507, + 508, + 511, + 523, + 529, + 530, + 532, + 534, + 545, + 549, + 558, + 565, + 567, + 568, + 580, + 582, + 595, + 596, + 597, + 604, + 610, + 613, + 616, + 625, + 627, + 638, + 639, + 659 + ], + [ + 246, + 247, + 250, + 251, + 253, + 264, + 265, + 269, + 271, + 275, + 279, + 281, + 282, + 288, + 297, + 303, + 318, + 327, + 331, + 332, + 337, + 342, + 343, + 344, + 347, + 354, + 355, + 357, + 360, + 361, + 364, + 367, + 373, + 374, + 381, + 388, + 391, + 396, + 397, + 404, + 406, + 407, + 412, + 423, + 428, + 429, + 435, + 438, + 441, + 442, + 444, + 450, + 455, + 459, + 482, + 487, + 489, + 496, + 498, + 503, + 504, + 507, + 531, + 532, + 565, + 568, + 569, + 570, + 575, + 596, + 601, + 604, + 619, + 622, + 631, + 638, + 639, + 652, + 657 + ], + [ + 252, + 253, + 261, + 263, + 267, + 272, + 274, + 275, + 281, + 285, + 288, + 293, + 297, + 303, + 309, + 316, + 318, + 326, + 338, + 339, + 342, + 343, + 344, + 349, + 356, + 357, + 358, + 360, + 361, + 366, + 367, + 368, + 378, + 379, + 384, + 388, + 391, + 392, + 396, + 404, + 405, + 409, + 414, + 416, + 419, + 426, + 429, + 430, + 433, + 438, + 440, + 441, + 442, + 444, + 446, + 449, + 459, + 460, + 464, + 466, + 467, + 468, + 476, + 477, + 485, + 489, + 491, + 498, + 504, + 506, + 510, + 511, + 513, + 514, + 523, + 530, + 532, + 533, + 534, + 547, + 548, + 549, + 558, + 563, + 567, + 569, + 581, + 582, + 585, + 586, + 601, + 603, + 620, + 627, + 631, + 657, + 658, + 659 + ], + [ + 246, + 247, + 264, + 279, + 281, + 282, + 285, + 286, + 295, + 297, + 298, + 305, + 306, + 308, + 309, + 310, + 318, + 321, + 322, + 325, + 327, + 328, + 333, + 334, + 345, + 346, + 353, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 364, + 371, + 375, + 378, + 379, + 380, + 386, + 397, + 407, + 409, + 412, + 421, + 425, + 427, + 428, + 433, + 435, + 442, + 444, + 456, + 457, + 463, + 464, + 476, + 477, + 482, + 488, + 498, + 504, + 506, + 510, + 513, + 523, + 529, + 530, + 533, + 534, + 540, + 547, + 548, + 550, + 552, + 557, + 558, + 567, + 570, + 581, + 582, + 595, + 596, + 598, + 601, + 602, + 603, + 616, + 620, + 621, + 622, + 627, + 631, + 638, + 652, + 657, + 659 + ], + [ + 246, + 250, + 251, + 253, + 264, + 265, + 275, + 279, + 290, + 293, + 297, + 303, + 305, + 306, + 310, + 316, + 318, + 321, + 322, + 327, + 328, + 330, + 331, + 333, + 335, + 342, + 343, + 347, + 353, + 354, + 355, + 356, + 357, + 359, + 360, + 363, + 364, + 367, + 368, + 373, + 375, + 378, + 381, + 384, + 388, + 392, + 399, + 402, + 407, + 408, + 412, + 418, + 421, + 428, + 430, + 433, + 442, + 444, + 449, + 450, + 459, + 461, + 463, + 482, + 487, + 488, + 496, + 498, + 503, + 508, + 509, + 513, + 514, + 530, + 531, + 557, + 568, + 570, + 596, + 638, + 639, + 657, + 658 + ], + [ + 247, + 248, + 250, + 251, + 253, + 255, + 265, + 267, + 269, + 275, + 285, + 290, + 297, + 303, + 306, + 308, + 310, + 313, + 314, + 325, + 331, + 333, + 334, + 335, + 339, + 342, + 343, + 344, + 346, + 349, + 355, + 358, + 363, + 367, + 371, + 373, + 374, + 375, + 376, + 377, + 379, + 380, + 381, + 383, + 386, + 392, + 395, + 396, + 401, + 402, + 404, + 405, + 409, + 411, + 419, + 425, + 426, + 429, + 435, + 438, + 439, + 442, + 444, + 453, + 455, + 457, + 459, + 467, + 469, + 471, + 473, + 475, + 477, + 491, + 492, + 497, + 503, + 504, + 511, + 514, + 515, + 530, + 534, + 545, + 551, + 557, + 558, + 567, + 569, + 580, + 582, + 584, + 597, + 603, + 610, + 613, + 616, + 621, + 622, + 625, + 652, + 658 + ], + [ + 246, + 247, + 251, + 252, + 264, + 269, + 279, + 282, + 293, + 299, + 309, + 310, + 313, + 325, + 327, + 328, + 332, + 333, + 339, + 341, + 342, + 344, + 345, + 347, + 354, + 355, + 359, + 362, + 367, + 368, + 374, + 375, + 380, + 381, + 388, + 392, + 396, + 400, + 401, + 405, + 407, + 409, + 413, + 416, + 419, + 425, + 426, + 427, + 430, + 433, + 440, + 441, + 455, + 460, + 482, + 483, + 488, + 496, + 498, + 506, + 508, + 511, + 529, + 530, + 531, + 532, + 534, + 568, + 595, + 596, + 638, + 639, + 657, + 658 + ], + [ + 246, + 247, + 251, + 259, + 264, + 275, + 281, + 282, + 290, + 297, + 305, + 306, + 309, + 310, + 313, + 316, + 322, + 325, + 330, + 333, + 344, + 345, + 353, + 355, + 358, + 367, + 368, + 374, + 375, + 376, + 380, + 381, + 384, + 388, + 393, + 396, + 400, + 401, + 405, + 406, + 407, + 409, + 413, + 414, + 416, + 419, + 421, + 425, + 426, + 427, + 428, + 429, + 430, + 432, + 435, + 449, + 450, + 461, + 482, + 483, + 487, + 492, + 496, + 498, + 506, + 507, + 511, + 515, + 529, + 530, + 531, + 532, + 534, + 557, + 567, + 568, + 595, + 596, + 638, + 639, + 657 + ], + [ + 251, + 252, + 263, + 267, + 269, + 279, + 281, + 286, + 293, + 303, + 306, + 313, + 314, + 316, + 318, + 327, + 328, + 333, + 342, + 344, + 345, + 349, + 354, + 358, + 360, + 367, + 371, + 373, + 374, + 378, + 380, + 382, + 383, + 384, + 388, + 392, + 395, + 397, + 399, + 401, + 404, + 406, + 407, + 411, + 413, + 414, + 419, + 425, + 427, + 428, + 438, + 439, + 449, + 450, + 459, + 463, + 466, + 467, + 468, + 482, + 483, + 487, + 489, + 490, + 492, + 496, + 504, + 506, + 513, + 531, + 540, + 552, + 567, + 568, + 570, + 580, + 597, + 610, + 616, + 625, + 639, + 651, + 657, + 658 + ], + [ + 246, + 247, + 248, + 251, + 252, + 255, + 264, + 267, + 281, + 282, + 285, + 288, + 293, + 295, + 298, + 301, + 306, + 308, + 309, + 310, + 313, + 314, + 316, + 318, + 322, + 325, + 331, + 334, + 335, + 337, + 343, + 345, + 347, + 349, + 353, + 354, + 356, + 357, + 360, + 361, + 364, + 366, + 367, + 373, + 374, + 377, + 379, + 384, + 386, + 396, + 398, + 399, + 402, + 404, + 405, + 408, + 412, + 413, + 414, + 416, + 418, + 428, + 433, + 435, + 438, + 439, + 441, + 444, + 449, + 450, + 455, + 456, + 457, + 460, + 461, + 463, + 467, + 469, + 471, + 473, + 475, + 477, + 483, + 489, + 493, + 494, + 495, + 498, + 506, + 508, + 511, + 545, + 596, + 597, + 613, + 616, + 638, + 639, + 657 + ], + [ + 247, + 250, + 252, + 253, + 265, + 274, + 275, + 279, + 282, + 288, + 290, + 297, + 298, + 303, + 304, + 305, + 306, + 314, + 316, + 320, + 321, + 322, + 327, + 328, + 331, + 333, + 335, + 344, + 345, + 347, + 353, + 360, + 364, + 367, + 368, + 373, + 374, + 378, + 380, + 381, + 392, + 397, + 398, + 399, + 404, + 405, + 406, + 414, + 425, + 428, + 429, + 430, + 435, + 440, + 442, + 455, + 459, + 461, + 463, + 483, + 487, + 488, + 490, + 503, + 506, + 508, + 511, + 513, + 514, + 529, + 531, + 532, + 539, + 540, + 545, + 557, + 566, + 569, + 576, + 581, + 597, + 601, + 613, + 616, + 619, + 622, + 631, + 658 + ], + [ + 263, + 267, + 269, + 274, + 282, + 285, + 286, + 289, + 290, + 295, + 297, + 306, + 308, + 309, + 310, + 313, + 314, + 322, + 325, + 326, + 331, + 334, + 335, + 345, + 346, + 349, + 352, + 355, + 356, + 360, + 363, + 366, + 368, + 371, + 375, + 381, + 383, + 391, + 395, + 396, + 397, + 398, + 402, + 406, + 407, + 413, + 416, + 428, + 429, + 430, + 432, + 438, + 440, + 450, + 456, + 457, + 461, + 466, + 467, + 468, + 482, + 489, + 507, + 547, + 549, + 550, + 551, + 552, + 558, + 563, + 581, + 582, + 583, + 584, + 585, + 597 + ], + [ + 274, + 281, + 290, + 293, + 303, + 305, + 316, + 318, + 322, + 328, + 332, + 333, + 338, + 342, + 346, + 349, + 353, + 354, + 358, + 359, + 360, + 367, + 370, + 371, + 373, + 375, + 376, + 378, + 379, + 380, + 382, + 384, + 391, + 392, + 397, + 398, + 401, + 404, + 406, + 411, + 416, + 424, + 428, + 429, + 432, + 433, + 438, + 442, + 444, + 450, + 459, + 461, + 464, + 476, + 477, + 488, + 490, + 492, + 494, + 495, + 506, + 511, + 513, + 523, + 532, + 533, + 549, + 557, + 558, + 567, + 580, + 581, + 582, + 596, + 597, + 601, + 610, + 622, + 625, + 627, + 631, + 638, + 639, + 652, + 659 + ], + [ + 247, + 250, + 251, + 253, + 263, + 265, + 267, + 272, + 275, + 282, + 288, + 290, + 293, + 295, + 303, + 305, + 308, + 309, + 310, + 314, + 328, + 333, + 334, + 335, + 338, + 342, + 343, + 345, + 349, + 354, + 355, + 357, + 359, + 360, + 361, + 367, + 370, + 371, + 374, + 375, + 379, + 380, + 381, + 386, + 388, + 392, + 400, + 401, + 404, + 412, + 413, + 425, + 427, + 430, + 432, + 433, + 435, + 438, + 439, + 440, + 441, + 442, + 444, + 446, + 456, + 457, + 459, + 460, + 461, + 464, + 466, + 467, + 468, + 476, + 477, + 486, + 492, + 496, + 503, + 504, + 509, + 510, + 514, + 523, + 529, + 531, + 533, + 548, + 550, + 568, + 569, + 581, + 582, + 586, + 595, + 596, + 601, + 602, + 620, + 627, + 631, + 638, + 639, + 651, + 659 + ], + [ + 263, + 267, + 269, + 274, + 282, + 285, + 286, + 290, + 295, + 297, + 306, + 308, + 309, + 310, + 313, + 314, + 322, + 325, + 326, + 331, + 334, + 335, + 343, + 345, + 346, + 352, + 355, + 356, + 360, + 363, + 366, + 368, + 370, + 371, + 375, + 381, + 382, + 383, + 388, + 391, + 395, + 396, + 397, + 398, + 402, + 406, + 407, + 413, + 416, + 428, + 429, + 430, + 432, + 438, + 440, + 450, + 456, + 457, + 461, + 463, + 466, + 467, + 468, + 482, + 489, + 507, + 548, + 549, + 551, + 552, + 558, + 563, + 582, + 583, + 585, + 586, + 597 + ], + [ + 246, + 247, + 251, + 252, + 264, + 275, + 281, + 282, + 290, + 297, + 305, + 306, + 309, + 310, + 313, + 316, + 322, + 325, + 330, + 333, + 336, + 338, + 344, + 345, + 353, + 358, + 368, + 374, + 375, + 376, + 380, + 381, + 388, + 396, + 399, + 400, + 401, + 405, + 406, + 407, + 409, + 413, + 414, + 416, + 419, + 421, + 425, + 426, + 427, + 428, + 429, + 430, + 432, + 435, + 449, + 450, + 461, + 482, + 483, + 487, + 493, + 496, + 498, + 506, + 507, + 510, + 511, + 529, + 530, + 531, + 532, + 534, + 557, + 567, + 568, + 595, + 596, + 638, + 639, + 657 + ], + [ + 247, + 250, + 252, + 253, + 265, + 275, + 281, + 288, + 293, + 297, + 299, + 303, + 309, + 310, + 313, + 318, + 325, + 328, + 331, + 333, + 337, + 339, + 343, + 345, + 357, + 360, + 361, + 364, + 367, + 368, + 375, + 376, + 380, + 391, + 392, + 397, + 400, + 401, + 404, + 405, + 406, + 409, + 412, + 413, + 416, + 419, + 423, + 425, + 426, + 427, + 428, + 429, + 430, + 433, + 435, + 438, + 440, + 442, + 444, + 450, + 459, + 460, + 483, + 487, + 503, + 504, + 507, + 508, + 509, + 511, + 529, + 530, + 534, + 565, + 567, + 569, + 570, + 575, + 595, + 601, + 604, + 619, + 622, + 631, + 652, + 658 + ], + [ + 247, + 250, + 252, + 253, + 265, + 269, + 274, + 275, + 279, + 281, + 286, + 293, + 296, + 297, + 298, + 303, + 310, + 314, + 320, + 327, + 330, + 332, + 337, + 344, + 347, + 356, + 357, + 360, + 363, + 364, + 367, + 368, + 375, + 376, + 381, + 391, + 396, + 398, + 402, + 405, + 408, + 414, + 418, + 421, + 423, + 425, + 428, + 433, + 438, + 440, + 441, + 442, + 449, + 459, + 483, + 487, + 488, + 490, + 503, + 504, + 507, + 511, + 514, + 532, + 540, + 545, + 566, + 575, + 576, + 581, + 597, + 604, + 613, + 616, + 652 + ], + [ + 242, + 243, + 247, + 250, + 251, + 253, + 263, + 265, + 272, + 274, + 275, + 285, + 286, + 290, + 293, + 295, + 301, + 303, + 306, + 313, + 314, + 318, + 322, + 328, + 339, + 342, + 344, + 347, + 357, + 359, + 360, + 361, + 363, + 364, + 370, + 371, + 373, + 376, + 380, + 381, + 382, + 386, + 388, + 407, + 412, + 419, + 423, + 427, + 428, + 438, + 439, + 446, + 449, + 450, + 453, + 459, + 460, + 466, + 468, + 469, + 473, + 475, + 477, + 482, + 488, + 489, + 503, + 508, + 509, + 523, + 533, + 540, + 545, + 547, + 548, + 550, + 552, + 558, + 565, + 569, + 575, + 582, + 602, + 603, + 604, + 613, + 619, + 620, + 621, + 627, + 639, + 659 + ], + [ + 242, + 243, + 251, + 252, + 267, + 269, + 274, + 279, + 282, + 285, + 286, + 290, + 293, + 295, + 303, + 308, + 313, + 316, + 327, + 330, + 332, + 334, + 337, + 339, + 342, + 344, + 353, + 355, + 356, + 359, + 360, + 363, + 366, + 367, + 373, + 382, + 383, + 388, + 395, + 396, + 400, + 401, + 402, + 405, + 406, + 408, + 409, + 414, + 418, + 421, + 426, + 428, + 430, + 435, + 438, + 450, + 457, + 459, + 460, + 463, + 467, + 469, + 473, + 475, + 477, + 483, + 487, + 490, + 504, + 511, + 523, + 529, + 530, + 533, + 534, + 540, + 545, + 549, + 552, + 557, + 558, + 570, + 582, + 595, + 596, + 601, + 613, + 622, + 627, + 631, + 638, + 651, + 652, + 657, + 659 + ], + [ + 246, + 247, + 257, + 263, + 270, + 274, + 281, + 290, + 298, + 299, + 305, + 306, + 314, + 316, + 321, + 322, + 332, + 333, + 334, + 335, + 337, + 343, + 353, + 354, + 358, + 363, + 373, + 374, + 376, + 377, + 378, + 384, + 388, + 398, + 399, + 405, + 407, + 414, + 421, + 423, + 425, + 427, + 430, + 438, + 440, + 441, + 444, + 460, + 461, + 463, + 466, + 468, + 472, + 478, + 482, + 487, + 488, + 492, + 495, + 496, + 498, + 500, + 507, + 509, + 511, + 513, + 530, + 531, + 557, + 570, + 575, + 595, + 597, + 638, + 639, + 654, + 655, + 657 + ], + [ + 246, + 247, + 263, + 270, + 272, + 274, + 286, + 290, + 297, + 301, + 303, + 308, + 309, + 313, + 318, + 320, + 321, + 325, + 328, + 334, + 335, + 337, + 339, + 343, + 347, + 349, + 352, + 358, + 360, + 361, + 363, + 366, + 367, + 370, + 376, + 377, + 386, + 389, + 392, + 396, + 409, + 412, + 413, + 417, + 419, + 421, + 428, + 429, + 430, + 435, + 438, + 441, + 442, + 446, + 453, + 455, + 457, + 459, + 461, + 468, + 469, + 482, + 487, + 492, + 495, + 498, + 500, + 507, + 511, + 525, + 528, + 530, + 540, + 545, + 548, + 549, + 550, + 552, + 561, + 568, + 570, + 578, + 580, + 602, + 613, + 616, + 620, + 621, + 647, + 651, + 653 + ], + [ + 269, + 279, + 281, + 285, + 290, + 293, + 295, + 297, + 299, + 308, + 309, + 313, + 314, + 316, + 318, + 321, + 325, + 327, + 332, + 334, + 335, + 337, + 343, + 347, + 351, + 353, + 356, + 358, + 360, + 363, + 364, + 366, + 367, + 370, + 371, + 376, + 378, + 379, + 383, + 386, + 391, + 395, + 397, + 398, + 404, + 407, + 412, + 424, + 425, + 429, + 430, + 432, + 433, + 435, + 439, + 440, + 441, + 444, + 455, + 456, + 457, + 461, + 482, + 487, + 488, + 489, + 492, + 506, + 511, + 513, + 524, + 527, + 547, + 550, + 562, + 567, + 596, + 597, + 602, + 603, + 638, + 639, + 651, + 657 + ], + [ + 246, + 251, + 252, + 253, + 257, + 258, + 263, + 264, + 266, + 267, + 269, + 272, + 274, + 275, + 279, + 282, + 286, + 288, + 293, + 299, + 301, + 316, + 322, + 326, + 327, + 330, + 331, + 333, + 344, + 345, + 347, + 353, + 354, + 357, + 361, + 366, + 367, + 368, + 380, + 381, + 384, + 396, + 398, + 400, + 404, + 410, + 414, + 416, + 421, + 425, + 429, + 433, + 438, + 440, + 446, + 449, + 450, + 453, + 455, + 457, + 460, + 463, + 466, + 467, + 478, + 482, + 483, + 487, + 488, + 496, + 498, + 499, + 508, + 529, + 532, + 545, + 548, + 549, + 552, + 557, + 567, + 568, + 575, + 581, + 595, + 597, + 613, + 616, + 620, + 621, + 650, + 651, + 658 + ], + [ + 246, + 247, + 263, + 269, + 270, + 274, + 275, + 286, + 288, + 297, + 305, + 310, + 320, + 321, + 328, + 333, + 335, + 337, + 345, + 352, + 353, + 354, + 356, + 358, + 361, + 366, + 367, + 368, + 371, + 375, + 381, + 382, + 383, + 391, + 395, + 397, + 402, + 404, + 407, + 413, + 417, + 418, + 419, + 425, + 432, + 439, + 440, + 444, + 468, + 469, + 487, + 488, + 498, + 500, + 506, + 511, + 514, + 525, + 528, + 531, + 540, + 542, + 544, + 545, + 547, + 552, + 561, + 568, + 570, + 578, + 596, + 603, + 638, + 639, + 647, + 653, + 657 + ], + [ + 246, + 247, + 257, + 270, + 274, + 281, + 290, + 298, + 299, + 305, + 306, + 309, + 314, + 316, + 321, + 322, + 332, + 333, + 334, + 335, + 337, + 343, + 353, + 354, + 358, + 363, + 373, + 374, + 376, + 377, + 378, + 384, + 398, + 399, + 405, + 407, + 414, + 421, + 423, + 425, + 430, + 438, + 440, + 441, + 444, + 460, + 461, + 463, + 466, + 468, + 478, + 482, + 487, + 488, + 492, + 495, + 496, + 498, + 500, + 507, + 509, + 511, + 513, + 530, + 531, + 557, + 570, + 575, + 595, + 596, + 598, + 638, + 639, + 654, + 658 + ], + [ + 266, + 269, + 272, + 281, + 282, + 286, + 288, + 297, + 301, + 303, + 305, + 308, + 309, + 313, + 314, + 321, + 325, + 328, + 330, + 333, + 334, + 337, + 347, + 349, + 352, + 353, + 358, + 363, + 366, + 367, + 371, + 376, + 378, + 379, + 382, + 383, + 388, + 391, + 398, + 404, + 406, + 407, + 410, + 416, + 425, + 429, + 430, + 435, + 441, + 442, + 444, + 446, + 453, + 455, + 457, + 459, + 463, + 482, + 488, + 489, + 490, + 492, + 496, + 505, + 513, + 514, + 528, + 533, + 548, + 549, + 552, + 557, + 564, + 567, + 569, + 575, + 581, + 596, + 597, + 601, + 620, + 621, + 622, + 631, + 638, + 639, + 649, + 650, + 651, + 652, + 657, + 658 + ], + [ + 246, + 251, + 252, + 253, + 255, + 256, + 257, + 258, + 263, + 264, + 267, + 269, + 274, + 275, + 279, + 285, + 286, + 288, + 290, + 293, + 297, + 298, + 299, + 305, + 306, + 313, + 320, + 321, + 325, + 326, + 327, + 331, + 333, + 334, + 339, + 353, + 356, + 371, + 383, + 395, + 399, + 409, + 414, + 419, + 423, + 424, + 425, + 427, + 428, + 429, + 432, + 433, + 435, + 440, + 444, + 453, + 455, + 457, + 463, + 464, + 466, + 467, + 469, + 471, + 475, + 476, + 478, + 482, + 483, + 496, + 498, + 499, + 524, + 527, + 530, + 531, + 534, + 543, + 547, + 549, + 552, + 557, + 562, + 567, + 569, + 579, + 580, + 596, + 597, + 603, + 609, + 610, + 621, + 622, + 625, + 638, + 639, + 642, + 652, + 654, + 657 + ], + [ + 242, + 243, + 246, + 251, + 258, + 261, + 264, + 267, + 272, + 279, + 281, + 282, + 286, + 288, + 295, + 299, + 305, + 310, + 322, + 326, + 327, + 331, + 333, + 338, + 339, + 342, + 343, + 344, + 347, + 355, + 356, + 358, + 363, + 367, + 370, + 374, + 378, + 380, + 381, + 383, + 384, + 386, + 388, + 395, + 396, + 399, + 401, + 411, + 416, + 425, + 426, + 427, + 428, + 444, + 446, + 450, + 457, + 461, + 464, + 466, + 467, + 469, + 473, + 475, + 476, + 482, + 483, + 485, + 487, + 488, + 489, + 490, + 491, + 496, + 499, + 504, + 505, + 506, + 510, + 513, + 528, + 531, + 548, + 550, + 552, + 563, + 567, + 569, + 575, + 577, + 585, + 586, + 597, + 604, + 607, + 620, + 622, + 650, + 658 + ], + [ + 242, + 243, + 256, + 272, + 275, + 281, + 290, + 293, + 297, + 301, + 305, + 306, + 307, + 309, + 314, + 320, + 326, + 330, + 331, + 332, + 334, + 344, + 356, + 357, + 360, + 366, + 367, + 368, + 371, + 376, + 377, + 378, + 379, + 384, + 391, + 396, + 399, + 401, + 404, + 411, + 414, + 416, + 417, + 419, + 421, + 425, + 426, + 427, + 428, + 430, + 438, + 439, + 440, + 442, + 444, + 446, + 453, + 455, + 456, + 457, + 460, + 463, + 469, + 475, + 477, + 482, + 488, + 492, + 496, + 507, + 509, + 514, + 523, + 529, + 531, + 543, + 545, + 557, + 560, + 567, + 568, + 575, + 587, + 595, + 596, + 605, + 607, + 613, + 627, + 638, + 642, + 656, + 658, + 659 + ], + [ + 262, + 269, + 279, + 281, + 285, + 290, + 293, + 295, + 297, + 298, + 299, + 308, + 309, + 313, + 314, + 316, + 318, + 321, + 325, + 332, + 334, + 335, + 337, + 343, + 345, + 353, + 356, + 358, + 360, + 363, + 364, + 366, + 367, + 370, + 371, + 376, + 378, + 379, + 383, + 386, + 391, + 394, + 395, + 397, + 398, + 405, + 407, + 412, + 414, + 425, + 429, + 430, + 432, + 433, + 435, + 439, + 440, + 441, + 444, + 455, + 456, + 457, + 461, + 482, + 487, + 488, + 489, + 492, + 506, + 511, + 513, + 523, + 527, + 547, + 550, + 559, + 561, + 567, + 596, + 597, + 602, + 603, + 638, + 639, + 651, + 657 + ], + [ + 246, + 247, + 257, + 270, + 281, + 285, + 286, + 288, + 295, + 297, + 298, + 303, + 305, + 307, + 313, + 316, + 321, + 325, + 328, + 331, + 334, + 347, + 352, + 370, + 374, + 377, + 379, + 381, + 384, + 386, + 391, + 392, + 397, + 398, + 400, + 401, + 404, + 412, + 413, + 414, + 419, + 429, + 430, + 432, + 433, + 435, + 440, + 444, + 455, + 456, + 457, + 459, + 460, + 468, + 478, + 482, + 487, + 488, + 498, + 500, + 507, + 509, + 513, + 514, + 533, + 534, + 540, + 545, + 548, + 550, + 552, + 557, + 558, + 568, + 570, + 575, + 582, + 587, + 601, + 602, + 613, + 620, + 621, + 622, + 631, + 639, + 651, + 652, + 656, + 658 + ], + [ + 246, + 251, + 252, + 253, + 258, + 262, + 263, + 264, + 272, + 274, + 275, + 282, + 286, + 288, + 290, + 295, + 298, + 305, + 308, + 309, + 313, + 325, + 326, + 327, + 328, + 330, + 335, + 339, + 344, + 349, + 354, + 355, + 356, + 360, + 364, + 367, + 370, + 371, + 374, + 377, + 379, + 384, + 386, + 391, + 392, + 394, + 396, + 398, + 400, + 401, + 402, + 404, + 405, + 412, + 413, + 418, + 425, + 428, + 435, + 441, + 444, + 446, + 456, + 457, + 461, + 463, + 468, + 469, + 482, + 483, + 487, + 498, + 499, + 527, + 529, + 533, + 542, + 545, + 548, + 549, + 550, + 552, + 558, + 559, + 568, + 569, + 582, + 594, + 595, + 596, + 597, + 601, + 602, + 613, + 616, + 620, + 631, + 638, + 639, + 647, + 651, + 658 + ], + [ + 246, + 247, + 257, + 270, + 274, + 286, + 290, + 293, + 303, + 308, + 313, + 314, + 316, + 318, + 324, + 325, + 328, + 332, + 333, + 335, + 343, + 344, + 349, + 353, + 354, + 356, + 360, + 374, + 375, + 376, + 379, + 380, + 381, + 382, + 395, + 398, + 407, + 413, + 414, + 416, + 419, + 421, + 425, + 426, + 435, + 439, + 444, + 449, + 459, + 461, + 468, + 478, + 487, + 488, + 489, + 492, + 495, + 498, + 500, + 507, + 512, + 514, + 529, + 532, + 533, + 540, + 545, + 547, + 549, + 552, + 557, + 558, + 581, + 601, + 603, + 613, + 622, + 631, + 639, + 652, + 655, + 657 + ], + [ + 242, + 243, + 246, + 251, + 252, + 253, + 258, + 263, + 264, + 269, + 274, + 282, + 285, + 288, + 290, + 293, + 295, + 308, + 309, + 314, + 316, + 318, + 321, + 325, + 330, + 333, + 334, + 335, + 339, + 349, + 357, + 360, + 361, + 366, + 367, + 368, + 371, + 375, + 376, + 378, + 379, + 380, + 381, + 388, + 395, + 401, + 411, + 413, + 414, + 416, + 417, + 422, + 425, + 430, + 433, + 435, + 439, + 441, + 449, + 450, + 455, + 457, + 463, + 466, + 468, + 469, + 473, + 475, + 477, + 483, + 487, + 489, + 492, + 496, + 498, + 499, + 508, + 513, + 514, + 523, + 532, + 545, + 549, + 557, + 558, + 564, + 569, + 575, + 577, + 582, + 597, + 600, + 601, + 604, + 607, + 613, + 616, + 627, + 652, + 657, + 659 + ], + [ + 242, + 243, + 256, + 269, + 274, + 285, + 290, + 295, + 298, + 303, + 305, + 306, + 313, + 320, + 321, + 324, + 325, + 326, + 334, + 335, + 339, + 345, + 352, + 356, + 357, + 360, + 365, + 366, + 367, + 376, + 377, + 378, + 379, + 380, + 381, + 383, + 391, + 399, + 400, + 404, + 409, + 411, + 414, + 417, + 418, + 419, + 421, + 425, + 427, + 430, + 433, + 435, + 439, + 440, + 441, + 449, + 455, + 457, + 459, + 463, + 469, + 475, + 477, + 482, + 489, + 492, + 496, + 506, + 512, + 513, + 523, + 524, + 530, + 532, + 534, + 541, + 545, + 557, + 560, + 567, + 570, + 579, + 581, + 582, + 595, + 605, + 607, + 616, + 627, + 639, + 642, + 655, + 659 + ], + [ + 241, + 243, + 246, + 255, + 264, + 274, + 278, + 282, + 286, + 287, + 288, + 290, + 298, + 299, + 302, + 305, + 306, + 313, + 325, + 332, + 333, + 337, + 347, + 349, + 352, + 353, + 355, + 357, + 359, + 360, + 364, + 367, + 368, + 370, + 374, + 378, + 380, + 382, + 386, + 395, + 397, + 400, + 401, + 405, + 406, + 407, + 412, + 414, + 416, + 421, + 424, + 427, + 429, + 439, + 441, + 442, + 449, + 450, + 452, + 453, + 455, + 458, + 459, + 463, + 467, + 468, + 469, + 473, + 475, + 477, + 484, + 488, + 490, + 492, + 498, + 504, + 505, + 513, + 519, + 523, + 529, + 530, + 531, + 534, + 547, + 550, + 552, + 558, + 567, + 570, + 580, + 581, + 582, + 587, + 595, + 602, + 603, + 604, + 610, + 616, + 621, + 625, + 627, + 636, + 638, + 645, + 657, + 659 + ], + [ + 241, + 243, + 246, + 255, + 264, + 272, + 276, + 279, + 281, + 286, + 288, + 293, + 294, + 298, + 299, + 301, + 302, + 303, + 305, + 310, + 313, + 314, + 316, + 318, + 321, + 322, + 332, + 339, + 343, + 344, + 345, + 347, + 349, + 352, + 354, + 357, + 358, + 359, + 360, + 364, + 367, + 368, + 374, + 375, + 376, + 377, + 379, + 380, + 381, + 382, + 383, + 384, + 399, + 404, + 407, + 413, + 414, + 419, + 421, + 427, + 429, + 432, + 433, + 437, + 438, + 439, + 446, + 449, + 458, + 465, + 477, + 484, + 487, + 488, + 496, + 498, + 504, + 506, + 509, + 523, + 530, + 534, + 536, + 540, + 548, + 549, + 552, + 556, + 558, + 567, + 568, + 570, + 572, + 574, + 580, + 581, + 582, + 589, + 606, + 610, + 613, + 618, + 620, + 625, + 627, + 629, + 639, + 651, + 659 + ], + [ + 263, + 267, + 272, + 274, + 281, + 282, + 288, + 290, + 293, + 295, + 300, + 303, + 305, + 306, + 309, + 310, + 313, + 321, + 322, + 325, + 326, + 328, + 330, + 331, + 333, + 339, + 345, + 354, + 355, + 356, + 357, + 360, + 361, + 363, + 366, + 368, + 376, + 377, + 381, + 384, + 392, + 395, + 396, + 397, + 398, + 400, + 401, + 402, + 404, + 406, + 408, + 418, + 425, + 426, + 427, + 429, + 430, + 433, + 435, + 438, + 441, + 444, + 447, + 453, + 454, + 455, + 461, + 463, + 466, + 467, + 468, + 488, + 489, + 492, + 512, + 513, + 528, + 533, + 548, + 549, + 557, + 558, + 563, + 564, + 567, + 569, + 575, + 597, + 598, + 601, + 604, + 621, + 633, + 652, + 658 + ], + [ + 263, + 267, + 274, + 281, + 282, + 288, + 293, + 305, + 306, + 316, + 318, + 322, + 332, + 333, + 335, + 339, + 343, + 345, + 347, + 349, + 354, + 355, + 366, + 368, + 370, + 376, + 377, + 381, + 382, + 384, + 386, + 388, + 392, + 396, + 398, + 404, + 406, + 412, + 413, + 416, + 428, + 433, + 435, + 441, + 449, + 450, + 455, + 461, + 463, + 466, + 467, + 468, + 482, + 492, + 495, + 507, + 518, + 520, + 521, + 547, + 550, + 552, + 554, + 557, + 581, + 597, + 602, + 603, + 651, + 658 + ], + [ + 263, + 267, + 274, + 279, + 282, + 283, + 288, + 290, + 293, + 299, + 305, + 306, + 310, + 313, + 316, + 321, + 322, + 325, + 327, + 328, + 335, + 337, + 344, + 345, + 349, + 355, + 358, + 367, + 368, + 375, + 376, + 378, + 379, + 380, + 381, + 382, + 396, + 400, + 401, + 402, + 406, + 414, + 421, + 426, + 427, + 429, + 433, + 435, + 438, + 441, + 444, + 455, + 461, + 463, + 466, + 467, + 468, + 487, + 488, + 492, + 495, + 496, + 506, + 507, + 509, + 513, + 514, + 529, + 532, + 534, + 538, + 539, + 545, + 557, + 567, + 568, + 570, + 572, + 574, + 581, + 595, + 597 + ], + [ + 263, + 267, + 274, + 282, + 288, + 290, + 293, + 298, + 306, + 310, + 314, + 316, + 318, + 320, + 321, + 322, + 331, + 332, + 333, + 335, + 337, + 347, + 349, + 352, + 355, + 358, + 364, + 367, + 371, + 375, + 376, + 378, + 379, + 382, + 383, + 384, + 388, + 404, + 405, + 409, + 412, + 413, + 416, + 419, + 424, + 432, + 433, + 435, + 438, + 441, + 444, + 450, + 452, + 455, + 458, + 461, + 463, + 466, + 467, + 468, + 488, + 490, + 492, + 505, + 506, + 507, + 508, + 511, + 513, + 514, + 530, + 531, + 540, + 545, + 557, + 576, + 582, + 587, + 596, + 597, + 604, + 637, + 652, + 657, + 658 + ], + [ + 243, + 246, + 247, + 255, + 263, + 269, + 270, + 274, + 279, + 282, + 284, + 287, + 288, + 290, + 293, + 294, + 297, + 298, + 301, + 302, + 306, + 325, + 327, + 328, + 330, + 333, + 337, + 343, + 349, + 355, + 356, + 359, + 361, + 364, + 368, + 374, + 376, + 378, + 380, + 383, + 388, + 392, + 396, + 399, + 400, + 401, + 405, + 407, + 413, + 416, + 421, + 425, + 426, + 428, + 429, + 433, + 439, + 440, + 442, + 443, + 444, + 446, + 447, + 450, + 455, + 458, + 459, + 461, + 463, + 465, + 466, + 467, + 477, + 482, + 483, + 488, + 495, + 496, + 498, + 504, + 511, + 513, + 518, + 520, + 521, + 523, + 529, + 530, + 538, + 547, + 548, + 549, + 557, + 558, + 568, + 569, + 574, + 580, + 582, + 591, + 595, + 597, + 603, + 606, + 610, + 612, + 613, + 616, + 620, + 622, + 625, + 627, + 629, + 639, + 652, + 659 + ], + [ + 243, + 246, + 247, + 255, + 267, + 270, + 275, + 279, + 283, + 284, + 290, + 294, + 295, + 299, + 300, + 303, + 313, + 321, + 322, + 327, + 328, + 330, + 331, + 333, + 335, + 337, + 344, + 356, + 359, + 360, + 361, + 367, + 368, + 370, + 371, + 374, + 375, + 377, + 379, + 382, + 384, + 386, + 392, + 396, + 397, + 398, + 402, + 405, + 407, + 408, + 409, + 412, + 416, + 418, + 419, + 425, + 427, + 438, + 439, + 440, + 441, + 444, + 447, + 450, + 458, + 460, + 461, + 467, + 469, + 473, + 475, + 477, + 483, + 488, + 492, + 498, + 504, + 507, + 511, + 512, + 516, + 523, + 531, + 532, + 533, + 534, + 537, + 547, + 549, + 550, + 552, + 557, + 564, + 567, + 569, + 580, + 582, + 596, + 601, + 602, + 603, + 610, + 622, + 625, + 627, + 630, + 633, + 638, + 643, + 652, + 657, + 658, + 659 + ], + [ + 263, + 267, + 281, + 282, + 287, + 288, + 293, + 305, + 306, + 316, + 317, + 318, + 322, + 332, + 333, + 335, + 343, + 345, + 347, + 349, + 354, + 355, + 366, + 368, + 370, + 376, + 377, + 381, + 382, + 384, + 386, + 388, + 392, + 396, + 398, + 404, + 406, + 412, + 413, + 416, + 428, + 433, + 435, + 441, + 445, + 449, + 450, + 455, + 460, + 463, + 466, + 467, + 468, + 492, + 495, + 507, + 519, + 521, + 547, + 550, + 552, + 553, + 557, + 581, + 597, + 602, + 603, + 651, + 658 + ], + [ + 241, + 244, + 246, + 263, + 264, + 269, + 276, + 279, + 282, + 283, + 284, + 285, + 286, + 288, + 298, + 299, + 302, + 303, + 308, + 313, + 327, + 333, + 334, + 343, + 345, + 352, + 356, + 358, + 359, + 360, + 361, + 363, + 364, + 371, + 376, + 380, + 382, + 383, + 392, + 398, + 400, + 405, + 406, + 409, + 421, + 425, + 426, + 432, + 437, + 441, + 444, + 446, + 447, + 450, + 455, + 458, + 460, + 461, + 464, + 465, + 466, + 468, + 469, + 477, + 482, + 484, + 488, + 496, + 498, + 504, + 506, + 507, + 509, + 511, + 514, + 529, + 531, + 533, + 540, + 548, + 552, + 553, + 570, + 573, + 581, + 595, + 596, + 601, + 611, + 616, + 620, + 622, + 623, + 624, + 630, + 631, + 638, + 643, + 651, + 652 + ], + [ + 263, + 267, + 272, + 273, + 274, + 281, + 282, + 288, + 290, + 293, + 295, + 301, + 305, + 306, + 309, + 310, + 313, + 321, + 322, + 325, + 326, + 328, + 330, + 331, + 333, + 339, + 345, + 354, + 355, + 356, + 357, + 360, + 361, + 363, + 366, + 368, + 376, + 377, + 381, + 384, + 392, + 395, + 396, + 397, + 398, + 400, + 401, + 402, + 404, + 406, + 408, + 418, + 425, + 426, + 427, + 429, + 430, + 433, + 435, + 438, + 441, + 444, + 447, + 455, + 456, + 461, + 463, + 466, + 467, + 468, + 488, + 489, + 492, + 508, + 512, + 513, + 528, + 533, + 548, + 549, + 557, + 558, + 563, + 564, + 567, + 569, + 575, + 597, + 598, + 601, + 604, + 619, + 620, + 631, + 632, + 633, + 634, + 652, + 658 + ], + [ + 241, + 247, + 249, + 257, + 264, + 267, + 270, + 272, + 274, + 275, + 278, + 282, + 285, + 287, + 297, + 299, + 301, + 303, + 305, + 306, + 310, + 318, + 321, + 322, + 324, + 332, + 334, + 337, + 343, + 347, + 349, + 352, + 355, + 359, + 361, + 363, + 366, + 370, + 371, + 374, + 376, + 377, + 378, + 384, + 386, + 392, + 398, + 399, + 401, + 405, + 406, + 407, + 409, + 411, + 413, + 416, + 421, + 428, + 429, + 432, + 433, + 435, + 439, + 444, + 447, + 453, + 457, + 458, + 459, + 464, + 478, + 484, + 487, + 495, + 496, + 500, + 504, + 508, + 512, + 513, + 514, + 518, + 529, + 532, + 540, + 550, + 554, + 557, + 558, + 568, + 570, + 587, + 591, + 596, + 602, + 604, + 614, + 621, + 638, + 640, + 655 + ], + [ + 246, + 247, + 270, + 272, + 275, + 282, + 283, + 284, + 290, + 293, + 297, + 301, + 305, + 306, + 313, + 322, + 327, + 333, + 339, + 343, + 345, + 349, + 353, + 355, + 356, + 358, + 359, + 361, + 363, + 364, + 367, + 368, + 371, + 377, + 378, + 379, + 382, + 383, + 384, + 391, + 392, + 395, + 397, + 399, + 401, + 407, + 411, + 413, + 416, + 425, + 427, + 429, + 432, + 437, + 438, + 439, + 442, + 444, + 450, + 455, + 460, + 464, + 477, + 483, + 488, + 489, + 492, + 496, + 498, + 504, + 508, + 516, + 529, + 530, + 532, + 545, + 548, + 549, + 552, + 558, + 564, + 568, + 569, + 572, + 589, + 595, + 596, + 598, + 613, + 616, + 619, + 620, + 633, + 635, + 638, + 651 + ], + [ + 241, + 246, + 251, + 252, + 253, + 264, + 274, + 275, + 278, + 282, + 288, + 293, + 297, + 303, + 305, + 309, + 310, + 313, + 325, + 328, + 332, + 335, + 337, + 339, + 344, + 345, + 347, + 349, + 352, + 353, + 354, + 355, + 358, + 364, + 367, + 368, + 371, + 374, + 375, + 379, + 380, + 381, + 382, + 383, + 384, + 392, + 396, + 399, + 400, + 401, + 404, + 407, + 409, + 413, + 414, + 416, + 419, + 424, + 425, + 426, + 427, + 430, + 432, + 435, + 438, + 440, + 442, + 443, + 444, + 449, + 455, + 481, + 483, + 484, + 487, + 488, + 496, + 498, + 502, + 518, + 519, + 529, + 530, + 531, + 532, + 534, + 554, + 568, + 581, + 582, + 587, + 591, + 595, + 597, + 614, + 615, + 645, + 658 + ], + [ + 244, + 246, + 247, + 270, + 272, + 275, + 279, + 282, + 284, + 285, + 290, + 294, + 295, + 298, + 303, + 305, + 310, + 313, + 327, + 333, + 344, + 345, + 353, + 356, + 357, + 358, + 359, + 360, + 366, + 368, + 370, + 375, + 376, + 380, + 386, + 388, + 391, + 392, + 395, + 401, + 407, + 409, + 412, + 416, + 419, + 421, + 425, + 427, + 428, + 430, + 432, + 433, + 438, + 439, + 440, + 441, + 443, + 444, + 447, + 453, + 455, + 459, + 464, + 465, + 467, + 468, + 469, + 477, + 483, + 498, + 504, + 506, + 517, + 521, + 531, + 533, + 534, + 549, + 550, + 555, + 569, + 571, + 597, + 601, + 602, + 611, + 617, + 621, + 624, + 631, + 636, + 639, + 645, + 651, + 657, + 658 + ], + [ + 263, + 267, + 274, + 279, + 282, + 290, + 293, + 299, + 305, + 306, + 309, + 310, + 313, + 315, + 316, + 321, + 322, + 325, + 327, + 328, + 330, + 335, + 337, + 344, + 345, + 349, + 355, + 358, + 367, + 368, + 375, + 376, + 378, + 379, + 380, + 381, + 382, + 396, + 400, + 401, + 402, + 406, + 414, + 421, + 426, + 427, + 429, + 433, + 435, + 438, + 440, + 441, + 444, + 455, + 461, + 463, + 466, + 467, + 468, + 487, + 488, + 492, + 495, + 496, + 506, + 507, + 509, + 513, + 514, + 529, + 532, + 534, + 535, + 537, + 539, + 557, + 567, + 568, + 570, + 581, + 595, + 597 + ], + [ + 242, + 243, + 263, + 267, + 274, + 281, + 282, + 288, + 290, + 293, + 301, + 305, + 308, + 313, + 316, + 320, + 325, + 326, + 327, + 328, + 331, + 334, + 337, + 338, + 339, + 344, + 345, + 346, + 349, + 359, + 368, + 370, + 373, + 374, + 375, + 377, + 378, + 380, + 381, + 382, + 384, + 386, + 388, + 391, + 392, + 396, + 398, + 399, + 401, + 407, + 411, + 413, + 414, + 416, + 421, + 426, + 433, + 435, + 438, + 441, + 444, + 455, + 456, + 460, + 461, + 463, + 464, + 466, + 467, + 468, + 470, + 471, + 477, + 488, + 492, + 497, + 504, + 506, + 510, + 513, + 515, + 523, + 526, + 528, + 557, + 567, + 577, + 580, + 581, + 594, + 597, + 600, + 605, + 625, + 628, + 653, + 654, + 658, + 659 + ], + [ + 243, + 244, + 247, + 252, + 253, + 254, + 255, + 257, + 261, + 263, + 265, + 267, + 272, + 274, + 279, + 283, + 284, + 286, + 287, + 288, + 290, + 293, + 295, + 299, + 301, + 303, + 305, + 306, + 309, + 313, + 314, + 318, + 319, + 325, + 327, + 328, + 330, + 333, + 337, + 339, + 342, + 349, + 354, + 355, + 360, + 361, + 363, + 367, + 368, + 370, + 371, + 374, + 378, + 380, + 386, + 388, + 395, + 398, + 399, + 402, + 412, + 413, + 418, + 419, + 421, + 425, + 426, + 427, + 433, + 435, + 437, + 438, + 441, + 442, + 443, + 444, + 447, + 453, + 459, + 461, + 464, + 467, + 478, + 486, + 507, + 509, + 511, + 513, + 519, + 523, + 525, + 530, + 531, + 532, + 537, + 540, + 542, + 550, + 552, + 558, + 561, + 568, + 570, + 580, + 582, + 602, + 610, + 616, + 617, + 621, + 623, + 625, + 627, + 630, + 636, + 651, + 657, + 659 + ], + [ + 256, + 257, + 274, + 281, + 282, + 288, + 290, + 293, + 298, + 306, + 308, + 310, + 312, + 313, + 316, + 322, + 325, + 328, + 330, + 331, + 332, + 333, + 335, + 337, + 339, + 343, + 353, + 357, + 359, + 361, + 363, + 373, + 374, + 375, + 378, + 391, + 392, + 399, + 401, + 402, + 404, + 405, + 413, + 416, + 418, + 421, + 426, + 428, + 430, + 433, + 435, + 438, + 441, + 444, + 455, + 460, + 461, + 463, + 467, + 468, + 473, + 486, + 488, + 491, + 506, + 507, + 509, + 513, + 525, + 542, + 543, + 557, + 560, + 561, + 567, + 579, + 593, + 644, + 646, + 658 + ], + [ + 242, + 244, + 247, + 250, + 251, + 252, + 255, + 256, + 257, + 261, + 262, + 265, + 269, + 274, + 281, + 282, + 290, + 305, + 310, + 313, + 316, + 325, + 326, + 330, + 331, + 332, + 333, + 353, + 354, + 357, + 358, + 359, + 361, + 374, + 377, + 378, + 384, + 388, + 398, + 400, + 401, + 405, + 409, + 411, + 414, + 419, + 421, + 423, + 425, + 426, + 427, + 430, + 435, + 436, + 438, + 444, + 450, + 460, + 461, + 464, + 466, + 468, + 469, + 473, + 477, + 478, + 480, + 482, + 492, + 496, + 502, + 504, + 506, + 511, + 513, + 529, + 530, + 531, + 532, + 534, + 538, + 545, + 553, + 556, + 557, + 567, + 568, + 571, + 574, + 577, + 580, + 595, + 596, + 597, + 605, + 607, + 610, + 628, + 638, + 639, + 653, + 657 + ], + [ + 243, + 244, + 247, + 252, + 253, + 254, + 255, + 261, + 263, + 265, + 272, + 274, + 275, + 281, + 283, + 286, + 287, + 288, + 294, + 301, + 302, + 306, + 308, + 327, + 328, + 330, + 334, + 342, + 343, + 345, + 349, + 354, + 356, + 359, + 361, + 363, + 364, + 367, + 373, + 380, + 381, + 383, + 388, + 392, + 396, + 402, + 404, + 407, + 413, + 418, + 419, + 426, + 427, + 428, + 430, + 433, + 437, + 439, + 440, + 443, + 446, + 458, + 459, + 460, + 464, + 466, + 467, + 478, + 488, + 491, + 506, + 507, + 511, + 518, + 523, + 525, + 530, + 531, + 532, + 540, + 542, + 547, + 548, + 549, + 552, + 554, + 558, + 561, + 567, + 568, + 570, + 572, + 580, + 582, + 596, + 603, + 610, + 612, + 616, + 618, + 620, + 625, + 627, + 638, + 639, + 644, + 646, + 659 + ], + [ + 244, + 247, + 250, + 251, + 252, + 256, + 257, + 261, + 262, + 263, + 265, + 267, + 269, + 280, + 288, + 293, + 308, + 310, + 320, + 327, + 328, + 330, + 332, + 333, + 334, + 337, + 338, + 339, + 344, + 345, + 346, + 349, + 353, + 354, + 357, + 358, + 361, + 368, + 370, + 373, + 375, + 380, + 381, + 382, + 386, + 391, + 392, + 396, + 399, + 400, + 405, + 407, + 409, + 413, + 416, + 419, + 423, + 425, + 427, + 430, + 441, + 450, + 455, + 463, + 467, + 469, + 473, + 478, + 480, + 482, + 488, + 496, + 497, + 502, + 510, + 511, + 515, + 523, + 526, + 529, + 530, + 531, + 532, + 534, + 538, + 545, + 553, + 556, + 568, + 571, + 574, + 581, + 594, + 595, + 596, + 608, + 626, + 638, + 639, + 654, + 657, + 658, + 659 + ], + [ + 242, + 244, + 247, + 252, + 253, + 254, + 255, + 256, + 257, + 261, + 262, + 265, + 274, + 279, + 281, + 286, + 288, + 290, + 293, + 297, + 301, + 303, + 310, + 316, + 318, + 321, + 327, + 334, + 337, + 339, + 342, + 345, + 347, + 353, + 356, + 361, + 368, + 370, + 371, + 373, + 375, + 376, + 378, + 379, + 380, + 392, + 395, + 396, + 397, + 399, + 400, + 401, + 405, + 407, + 409, + 411, + 412, + 414, + 416, + 417, + 421, + 423, + 429, + 439, + 441, + 442, + 444, + 449, + 453, + 455, + 456, + 458, + 466, + 468, + 469, + 471, + 475, + 478, + 482, + 488, + 496, + 497, + 504, + 511, + 513, + 515, + 528, + 529, + 534, + 540, + 545, + 550, + 552, + 553, + 558, + 570, + 571, + 582, + 594, + 595, + 600, + 602, + 610, + 613, + 621, + 624, + 627, + 651, + 653, + 657, + 658 + ], + [ + 256, + 267, + 274, + 281, + 282, + 288, + 290, + 293, + 298, + 306, + 310, + 313, + 316, + 319, + 322, + 325, + 328, + 330, + 331, + 332, + 333, + 335, + 337, + 339, + 343, + 353, + 357, + 359, + 361, + 363, + 373, + 374, + 375, + 378, + 391, + 392, + 398, + 399, + 401, + 402, + 404, + 405, + 413, + 416, + 418, + 421, + 426, + 428, + 429, + 430, + 433, + 435, + 438, + 441, + 444, + 455, + 460, + 461, + 463, + 466, + 468, + 473, + 486, + 488, + 491, + 506, + 507, + 509, + 513, + 525, + 542, + 543, + 557, + 560, + 561, + 567, + 579, + 590, + 592, + 593, + 658 + ] + ], + "helper_only_adds": 12988, + "searched_orientations": { + "helper": 175980, + "target": 14280 + }, + "target_search": { + "method": "best assignment to donors, at most 30 strictly improving single-donor toggles", + "donors": [ + 120, + 123, + 124, + 127, + 132, + 133, + 134, + 138, + 139, + 143, + 144, + 145, + 151, + 152, + 153, + 154, + 156, + 157, + 162, + 163, + 165, + 169, + 171, + 172, + 174, + 182, + 183, + 185, + 188, + 193, + 198, + 199, + 203, + 207, + 211, + 212, + 213, + 216, + 217, + 222, + 223, + 225, + 228, + 230, + 233, + 236, + 238 + ], + "saved_over_helper_only": 1478, + "trace": [ + [ + 56, + 1401 + ], + [ + 55, + 1415 + ], + [ + 54, + 1425 + ], + [ + 53, + 1434 + ], + [ + 52, + 1441 + ], + [ + 51, + 1448 + ], + [ + 52, + 1453 + ], + [ + 51, + 1458 + ], + [ + 50, + 1463 + ], + [ + 49, + 1466 + ], + [ + 48, + 1469 + ], + [ + 47, + 1472 + ], + [ + 46, + 1474 + ], + [ + 45, + 1476 + ], + [ + 46, + 1477 + ], + [ + 47, + 1478 + ] + ], + "evaluated_toggle_sets": 1920, + "maximum_iterations": 30 + } +} diff --git a/research/r420-two-sided-compensation/verify.py b/research/r420-two-sided-compensation/verify.py new file mode 100644 index 0000000000..a0b66b22c6 --- /dev/null +++ b/research/r420-two-sided-compensation/verify.py @@ -0,0 +1,160 @@ +"""Exact finite checker; prepared with substantial OpenAI Codex assistance. +Apache-2.0. Does not certify a changed recursive invoice or a new kappa. +""" +import argparse +import copy +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parent.parent +sys.path.insert(0, str(HERE)) +from construct import SOURCE, build, search + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(obj): + return hashlib.sha256(json.dumps(obj, sort_keys=True, separators=(",", ":")).encode()).hexdigest() + + +def execute(gates, n=660): + values = [1 << i for i in range(n)] + for frame, destination, sources in gates: + need(frame == 0, "D gate outside frame zero") + need(120 <= destination < n and sources and len(set(sources)) == len(sources), "invalid D destination/sources") + need(all(120 <= s < n and s != destination for s in sources), "invalid D operand") + for source in sources: + values[destination] ^= values[source] + return values + + +def semantic_d(baseline, candidate): + need(set(baseline) == set(candidate), "word keys changed") + need(all(candidate[k] == baseline[k] for k in baseline if k != "D"), "field outside D changed") + need(execute(candidate["D"]) == execute(baseline["D"]), "D endpoint differs on arbitrary inputs") + + +def count(word): + return sum(len(g[2]) for sec in ("D", "A", "B", "C") for g in word[sec]) + sum(map(len, word["scatter"])) + + +def reject(action, name): + try: + action() + except ValueError: + return name + raise ValueError("negative control was accepted: " + name) + + +def evaluate(outdir): + pins = json.loads((HERE / "SOURCES.json").read_text()) + for path, expected in pins["files_sha256"].items(): + need(hashlib.sha256((ROOT / path).read_bytes()).hexdigest() == expected, "source pin: " + path) + baseline = json.load(gzip.open(SOURCE, "rt")) + need(digest(baseline) == pins["word_canonical_sha256"], "source word semantic pin") + recipe = json.loads((HERE / "recipe.json").read_text()) + need(recipe == search(baseline), "frozen seed-3 nomination differs") + candidate = build(baseline, recipe) + semantic_d(baseline, candidate) + spec = importlib.util.spec_from_file_location("predecessor_xcheck", ROOT / "research/e8-bit-r420/code/xcheck.py") + checker = importlib.util.module_from_spec(spec) + spec.loader.exec_module(checker) + W, labels, full, H, C, info = checker.check(baseline) + need(all(H.values()) and all(C.values()), "baseline interface rejected") + # Frames/labels are identical, so the exact geometry computed above is reusable. + W.w = candidate + candidate_full = W.full() + candidate_H, candidate_C, _ = W.interface() + need(not candidate_H["H2_D_frame0_targets_from_helpers"], "expected original H2 syntax rejection missing") + need(not candidate_C["K_equals_D"], "expected original literal K extractor rejection missing") + need(all(v for k,v in candidate_H.items() if k != "H2_D_frame0_targets_from_helpers"), "other interface condition changed") + need(all(v for k,v in candidate_C.items() if k != "K_equals_D"), "other interface conclusion changed") + controls = [] + hp, tp = len(recipe["helper_pairs"]), len(recipe["target_pairs"]) + for name, index in (("missing_helper_restoration", len(candidate["D"])-1), + ("missing_target_preparation", hp), + ("missing_target_restoration", len(candidate["D"])-hp-1)): + bad = copy.deepcopy(candidate) + del bad["D"][index] + controls.append(reject(lambda: semantic_d(baseline, bad), name)) + bad = copy.deepcopy(candidate) + bad["D"][hp+tp][2].pop() + controls.append(reject(lambda: semantic_d(baseline, bad), "missing_feed_term")) + bad = copy.deepcopy(candidate) + bad["D"][0][0] = 1 + controls.append(reject(lambda: semantic_d(baseline, bad), "unpaid_nonzero_frame")) + bad = copy.deepcopy(candidate) + bad["ret"][0] = bad["ret"][1] + controls.append(reject(lambda: semantic_d(baseline, bad), "changed_retained_total")) + bad_recipe = copy.deepcopy(recipe) + bad_recipe["transformed_rows"][0].pop() + controls.append(reject(lambda: semantic_d(baseline, build(baseline, bad_recipe)), "corrupt_transformed_matrix")) + # An F2-neutral gate pair is legal, but must pay two additional additions. + neutral = copy.deepcopy(candidate) + neutral["D"] = [[0,240,[241]], [0,240,[241]]] + neutral["D"] + semantic_d(baseline, neutral) + need(count(neutral) == count(candidate)+2, "neutral pair not charged") + controls.append(reject(lambda: need(count(neutral) == count(candidate), "underpriced neutral pair"), "underpriced_neutral_pair")) + outdir.mkdir(parents=True, exist_ok=True) + candidate_file = outdir / "candidate.json" + candidate_file.write_text(json.dumps(candidate, separators=(",", ":")) + "\n") + report = dict(status="PASS_FINITE_TWO_SIDED_D", columns=660, labels=labels, + baseline_word_sha256=digest(baseline), candidate_word_sha256=digest(candidate), + recipe_sha256=digest(recipe), + helper_pairs=hp, target_pairs=tp, + baseline_D_adds=sum(len(g[2]) for g in baseline["D"]), + helper_only_D_adds=recipe["helper_only_adds"], + candidate_D_adds=sum(len(g[2]) for g in candidate["D"]), + baseline_native_adds=count(baseline), candidate_native_adds=count(candidate), + saved_adds=count(baseline)-count(candidate), negative_controls=controls, + unchanged_interface=[k for k,v in candidate_H.items() if v], + original_syntax_rejections=["H2_D_frame0_targets_from_helpers", "K_equals_D"], + scope="Finite native circuit and semantic frame-zero D extension; no new kappa or hosted invoice") + return report, candidate_file + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + parser.add_argument("--write-certificate", action="store_true", help="explicitly regenerate this package's certificate") + args = parser.parse_args() + with tempfile.TemporaryDirectory(prefix="r420-two-sided-") as tmp: + out = args.output or Path(tmp) + report, candidate = evaluate(out) + independent = subprocess.run([sys.executable, "-B", str(HERE / "audit_independent.py"), + "--baseline", str(SOURCE), "--recipe", str(HERE / "recipe.json"), + "--candidate", str(candidate), "--output", str(out / "independent.json")], + capture_output=True, text=True) + need(independent.returncode == 0, "independent audit failed: " + independent.stdout + independent.stderr) + native = subprocess.run([sys.executable, "-B", str(HERE / "native.py"), str(candidate), + "--out", str(out / "native")], capture_output=True, text=True) + need(native.returncode == 0, "native audit failed: " + native.stdout + native.stderr) + native_report = json.loads((out / "native/RESULT.json").read_text()) + # Portable proof-relevant fields only; compiler paths and gzip bytes are execution metadata. + report["native"] = {name: {k:v for k,v in native_report[name].items() if k != "input_sha256"} + for name in ("baseline", "candidate")} + report["native"]["comparison"] = native_report["comparison"] + report["native"]["missing_D_negative_control"] = native_report["native_missing_D_negative_control"] + certificate = HERE / "CERTIFICATE.json" + if args.write_certificate: + certificate.write_text(json.dumps(report, indent=2) + "\n") + else: + need(report == json.loads(certificate.read_text()), "certificate does not match exact recomputation") + print("Independent set audit: PASS; native Python audit: PASS; official C++: " + native_report["official_cpp"]["status"]) + print("PASS_R420_TWO_SIDED D={baseline_D_adds}->{candidate_D_adds} " + "native_ADDs={baseline_native_adds}->{candidate_native_adds} " + "saved={saved_adds} columns=660 no_new_kappa".format(**report)) + + +if __name__ == "__main__": + main()