From 5a55ab7f2dcc6345a04dfe251d5e2d3bc824a385 Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Thu, 22 Oct 2026 23:16:39 -0500 Subject: [PATCH] Prove returned-register query floor and scoped clean-helper limits --- research/bit-clean-extra-register/README.md | 93 + .../SOURCE-MANIFEST.json | 143 + .../expected/all-basis-summary.json | 3170 ++++++++++++ .../expected/catalogue-audit.json | 71 + .../clean-zero-independent-order-result.json | 1 + .../expected/clean-zero-result.json | 46 + .../expected/selected-comparison.json | 2648 ++++++++++ research/bit-clean-extra-register/replay.log | 11 + .../replayed-receipt.json | 49 + .../review/REMOTE-PREDECESSORS.json | 26 + .../review/REVIEW.json | 144 + .../bit-clean-extra-register/review/REVIEW.md | 161 + .../review/REVIEWED-FILES.json | 145 + .../review/SOURCE-REVIEW.json | 223 + .../review/check_controls.py | 115 + .../review/check_reductions.json | 22 + .../review/check_reductions.py | 80 + .../review/controls.log | 1 + .../review/controls/receipt.json | 26 + .../review/eumemic-predecessor.txt | 380 ++ .../review/full-replay-runner.py | 167 + .../review/huxint-predecessor.txt | 355 ++ .../review/replay.log | 176 + .../review/replay/receipt.json | 49 + .../clean-ancilla/ALPHABETS.txt | 166 + .../clean-ancilla/RESULT.txt | 72 + .../clean-ancilla/run_two_bases.py | 40 + .../clean-ancilla/search.py | 84 + .../clean-ancilla/two_bases.cpp | 456 ++ .../clean-audit/PROOF-AUDIT.txt | 134 + .../clean-audit/selected_words.cpp | 23 + .../four-register/CLEAN-ONE-RELATION.txt | 140 + .../sources/four-register/CLEAN-SPAN-FOUR.txt | 86 + .../sources/four-register/F101-ARITHMETIC.txt | 64 + .../four-register/FINAL-CLEAN-REPORT.txt | 127 + .../sources/four-register/dirty_ancilla.py | 169 + .../check_clean_zero_orders.cpp | 96 + .../clean-zero-family-metadata.txt | 216 + .../independent/clean-zero/PROOF.txt | 99 + .../independent/clean-zero/field.cpp | 413 ++ .../independent/clean-zero/generate.py | 47 + .../independent/clean-zero/integer.cpp | 373 ++ research/bit-clean-extra-register/verify.py | 167 + .../bit-three-active-one-returned/AUDIT.txt | 323 ++ .../bit-three-active-one-returned/PROOF.txt | 168 + .../bit-three-active-one-returned/README.md | 108 + .../bit-three-active-one-returned/REPLAY.txt | 55 + .../SOURCE-MANIFEST.json | 167 + .../field101.cpp | 443 ++ .../bit-three-active-one-returned/generate.py | 259 + .../independent-receipt.json | 97 + .../independent-replay.log | 12 + .../work/four-register/DIRTY-MODEL.txt | 64 + .../work/four-register/F101-ARITHMETIC.txt | 64 + .../work/four-register/dirty_ancilla.py | 169 + .../work/four-register/dirty_f101_controls.py | 72 + .../work/four-register/dirty_h_alphabet.py | 106 + .../work/four-register/dirty_rank2.py | 49 + .../independent-audit/DIRTY-AUDIT.txt | 323 ++ .../independent-audit/PROOF-AUDIT.txt | 173 + .../independent-audit/check_input_binding.py | 73 + .../independent-audit/check_off_catalogue.py | 90 + .../independent-audit/check_rank2_orders.py | 79 + .../check_rank3_multisets.cpp | 126 + .../independent-audit/check_rank3_orders.cpp | 145 + .../independent/fraction-terminal-audit.json | 4314 +++++++++++++++++ .../independent/off_pattern_spaces.py | 50 + .../four-register/independent/rank2_binary.py | 49 + .../four-register/independent/rank3_data.py | 42 + .../multisets.cpp | 98 + .../bit-three-active-one-returned/orders.cpp | 116 + .../rational.cpp | 411 ++ .../receipt.json | 130 + .../bit-three-active-one-returned/replay.log | 6 + .../replayed-fraction-terminals.json | 4313 ++++++++++++++++ .../replayed-independent-receipt.json | 83 + .../replayed-receipt.json | 131 + .../review/CHECKED-FILES.json | 192 + .../review/CONTROLS.json | 24 + .../review/DEPENDENCY-AND-OVERLAP-PINS.json | 38 + .../review/ENVIRONMENT-GUARD.json | 6 + .../review/FRACTION-TERMINALS.json | 4313 ++++++++++++++++ .../review/INDEPENDENT-REPLAY-RECEIPT.json | 83 + .../review/PACKAGED-FRACTION-TERMINALS.json | 4313 ++++++++++++++++ .../review/REPLAY-RECEIPT.json | 132 + .../review/RESULT.json | 34 + .../review/REVIEW.txt | 191 + .../review/WRAPPER-FINDING.json | 11 + .../review/controls.py | 76 + .../review/environment_guard.py | 24 + .../review/fraction_terminals.py | 41 + .../review/independent-replay.log | 12 + .../review/replay.log | 6 + .../bit-three-active-one-returned/verify.py | 17 + .../verify_fraction_terminals.py | 44 + .../verify_independent.py | 98 + 96 files changed, 33837 insertions(+) create mode 100644 research/bit-clean-extra-register/README.md create mode 100644 research/bit-clean-extra-register/SOURCE-MANIFEST.json create mode 100644 research/bit-clean-extra-register/expected/all-basis-summary.json create mode 100644 research/bit-clean-extra-register/expected/catalogue-audit.json create mode 100644 research/bit-clean-extra-register/expected/clean-zero-independent-order-result.json create mode 100644 research/bit-clean-extra-register/expected/clean-zero-result.json create mode 100644 research/bit-clean-extra-register/expected/selected-comparison.json create mode 100644 research/bit-clean-extra-register/replay.log create mode 100644 research/bit-clean-extra-register/replayed-receipt.json create mode 100644 research/bit-clean-extra-register/review/REMOTE-PREDECESSORS.json create mode 100644 research/bit-clean-extra-register/review/REVIEW.json create mode 100644 research/bit-clean-extra-register/review/REVIEW.md create mode 100644 research/bit-clean-extra-register/review/REVIEWED-FILES.json create mode 100644 research/bit-clean-extra-register/review/SOURCE-REVIEW.json create mode 100644 research/bit-clean-extra-register/review/check_controls.py create mode 100644 research/bit-clean-extra-register/review/check_reductions.json create mode 100644 research/bit-clean-extra-register/review/check_reductions.py create mode 100644 research/bit-clean-extra-register/review/controls.log create mode 100644 research/bit-clean-extra-register/review/controls/receipt.json create mode 100644 research/bit-clean-extra-register/review/eumemic-predecessor.txt create mode 100644 research/bit-clean-extra-register/review/full-replay-runner.py create mode 100644 research/bit-clean-extra-register/review/huxint-predecessor.txt create mode 100644 research/bit-clean-extra-register/review/replay.log create mode 100644 research/bit-clean-extra-register/review/replay/receipt.json create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/RESULT.txt create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/run_two_bases.py create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/search.py create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/two_bases.cpp create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/rank-independent/clean-audit/PROOF-AUDIT.txt create mode 100644 research/bit-clean-extra-register/sources/doubling-architecture/rank-independent/clean-audit/selected_words.cpp create mode 100644 research/bit-clean-extra-register/sources/four-register/CLEAN-ONE-RELATION.txt create mode 100644 research/bit-clean-extra-register/sources/four-register/CLEAN-SPAN-FOUR.txt create mode 100644 research/bit-clean-extra-register/sources/four-register/F101-ARITHMETIC.txt create mode 100644 research/bit-clean-extra-register/sources/four-register/FINAL-CLEAN-REPORT.txt create mode 100644 research/bit-clean-extra-register/sources/four-register/dirty_ancilla.py create mode 100644 research/bit-clean-extra-register/sources/four-register/independent-audit/check_clean_zero_orders.cpp create mode 100644 research/bit-clean-extra-register/sources/four-register/independent-audit/clean-zero-family-metadata.txt create mode 100644 research/bit-clean-extra-register/sources/four-register/independent/clean-zero/PROOF.txt create mode 100644 research/bit-clean-extra-register/sources/four-register/independent/clean-zero/field.cpp create mode 100644 research/bit-clean-extra-register/sources/four-register/independent/clean-zero/generate.py create mode 100644 research/bit-clean-extra-register/sources/four-register/independent/clean-zero/integer.cpp create mode 100644 research/bit-clean-extra-register/verify.py create mode 100644 research/bit-three-active-one-returned/AUDIT.txt create mode 100644 research/bit-three-active-one-returned/PROOF.txt create mode 100644 research/bit-three-active-one-returned/README.md create mode 100644 research/bit-three-active-one-returned/REPLAY.txt create mode 100644 research/bit-three-active-one-returned/SOURCE-MANIFEST.json create mode 100644 research/bit-three-active-one-returned/field101.cpp create mode 100644 research/bit-three-active-one-returned/generate.py create mode 100644 research/bit-three-active-one-returned/independent-receipt.json create mode 100644 research/bit-three-active-one-returned/independent-replay.log create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/DIRTY-MODEL.txt create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/F101-ARITHMETIC.txt create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_ancilla.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_f101_controls.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_h_alphabet.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_rank2.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/DIRTY-AUDIT.txt create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/PROOF-AUDIT.txt create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_input_binding.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_off_catalogue.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank2_orders.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank3_multisets.cpp create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank3_orders.cpp create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent/fraction-terminal-audit.json create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent/off_pattern_spaces.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent/rank2_binary.py create mode 100644 research/bit-three-active-one-returned/independent-sources/work/four-register/independent/rank3_data.py create mode 100644 research/bit-three-active-one-returned/multisets.cpp create mode 100644 research/bit-three-active-one-returned/orders.cpp create mode 100644 research/bit-three-active-one-returned/rational.cpp create mode 100644 research/bit-three-active-one-returned/receipt.json create mode 100644 research/bit-three-active-one-returned/replay.log create mode 100644 research/bit-three-active-one-returned/replayed-fraction-terminals.json create mode 100644 research/bit-three-active-one-returned/replayed-independent-receipt.json create mode 100644 research/bit-three-active-one-returned/replayed-receipt.json create mode 100644 research/bit-three-active-one-returned/review/CHECKED-FILES.json create mode 100644 research/bit-three-active-one-returned/review/CONTROLS.json create mode 100644 research/bit-three-active-one-returned/review/DEPENDENCY-AND-OVERLAP-PINS.json create mode 100644 research/bit-three-active-one-returned/review/ENVIRONMENT-GUARD.json create mode 100644 research/bit-three-active-one-returned/review/FRACTION-TERMINALS.json create mode 100644 research/bit-three-active-one-returned/review/INDEPENDENT-REPLAY-RECEIPT.json create mode 100644 research/bit-three-active-one-returned/review/PACKAGED-FRACTION-TERMINALS.json create mode 100644 research/bit-three-active-one-returned/review/REPLAY-RECEIPT.json create mode 100644 research/bit-three-active-one-returned/review/RESULT.json create mode 100644 research/bit-three-active-one-returned/review/REVIEW.txt create mode 100644 research/bit-three-active-one-returned/review/WRAPPER-FINDING.json create mode 100644 research/bit-three-active-one-returned/review/controls.py create mode 100644 research/bit-three-active-one-returned/review/environment_guard.py create mode 100644 research/bit-three-active-one-returned/review/fraction_terminals.py create mode 100644 research/bit-three-active-one-returned/review/independent-replay.log create mode 100644 research/bit-three-active-one-returned/review/replay.log create mode 100644 research/bit-three-active-one-returned/verify.py create mode 100644 research/bit-three-active-one-returned/verify_fraction_terminals.py create mode 100644 research/bit-three-active-one-returned/verify_independent.py diff --git a/research/bit-clean-extra-register/README.md b/research/bit-clean-extra-register/README.md new file mode 100644 index 0000000000..eb24297a07 --- /dev/null +++ b/research/bit-clean-extra-register/README.md @@ -0,0 +1,93 @@ +# Restrictions for three active targets and one clean extra register + +This package proves restrictions on an eight-call formal binary circuit. +There are three active targets and one extra input that starts at zero. +The extra output is discarded. The required upper-left block is +`diag([C_1],[C_2],[C_3])`, where the targets are invertible lower-triangular +rational 3 by 3 frames. Paid factors are `I + ([A]-1)N`: `A` is nonzero +and has rational rank one, and `N` is a binary rank-one idempotent on +four registers. The coefficient ring is `F_2[M_3(Q)]`. +The endpoint is the product of these listed paid factors. No additional +free scalar map is applied at the end. The clean active-block condition +alone does not justify removing such a map from a broader circuit model. + +The [final report](sources/four-register/FINAL-CLEAN-REPORT.txt) states +the scope and proof dependencies. The results are: + +- Paid-frame span at most four needs at least nine calls. This bound + permits any number of clean extra registers. +- Span eight is impossible. Span seven forces zero active off-diagonal + entries in every scalar projector. +- For one clean extra register, the complete 24-projector class with + zero active off-diagonal entries is impossible in eight calls. +- Eight calls are also impossible over the union of the coordinate-basis + projectors and one arbitrary binary-basis set of projectors. + +The remaining arbitrary four-register problem has frame span five or six, +a nonzero active off-diagonal pattern, and an alphabet outside the last +class. It remains open here. Fixing one basis to the coordinate basis is +a restriction; it is not a normalization of every pair of bases. These +results give no construction, complete clean-register lower bound, or +new kappa value. + +The [span proof](sources/four-register/CLEAN-SPAN-FOUR.txt) extends the +method in [PR #468](https://github.com/CrocSwap/integer-mult-bounds/pull/468), +at its [recorded source](https://github.com/CrocSwap/integer-mult-bounds/blob/07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea/research/bit-three-register-lower-bound/README.md). +The [one-relation proof](sources/four-register/CLEAN-ONE-RELATION.txt), +[zero-pattern proof](sources/four-register/independent/clean-zero/PROOF.txt), +and [independent scope audit](sources/doubling-architecture/rank-independent/clean-audit/PROOF-AUDIT.txt) +give the other arguments. The predecessor credits the scalar model to +[PR #288](https://github.com/CrocSwap/integer-mult-bounds/pull/288), at +[its recorded source](https://github.com/eumemic/integer-mult-bounds/blob/475a088b5862f75f0b10596cfd6842d19531a5ec/research/negative-results-paradigm-search/README.md). +The pinned PR #468 proof also credits @huxint's +[PR #203](https://github.com/CrocSwap/integer-mult-bounds/pull/203) for the +related common triangular-frame obstruction, at +[its recorded commit](https://github.com/huxint/integer-mult-bounds/commit/d2873e20750d0949d2ad75cbc4cd82b5b1a74e84). +OpenAI Codex and research agents prepared the proof and checks under the +user's direction. No independent human review is claimed. + +From this package directory, with Python 3.10 or later and a C++17 compiler: + +```sh +python3 -B verify.py --build /tmp/clean-extra-register-replay +``` + +The build path must not exist. `CXX` can select the compiler. The runner +copies the saved source files there before any generated output is written. +It rejects optimized Python because some historical sources use assertions. +No repository source or third-party Python module is required. + +The final line must be: + +```text +PASS_CLEAN_RESTRICTED_CLASSES 314666 7406643 +``` + +The replay checks all 314,666 zero-pattern words with primitive-integer and +finite-field engines and compares every output record. A separate generator +checks all 3,674,160 raw orders by dependence signatures. It also checks +all 166 basis alphabets, with 7,406,643 words, in the finite-field engine. +The basis catalogue is reconstructed through dual-vector tests. A separate +rational engine checks 48 fixed words from the saved independent receipt. +The full basis search does not have a second complete arithmetic replay. + +`SOURCE-MANIFEST.json` records the original paths and hashes. Source bytes +are unchanged. The new runner only makes the existing checks portable and +compares their outcomes. `expected/` contains historical receipts. The +new `replayed-receipt.json` and `replay.log` record the cleanup audit run. +Historical prose can name receipts at their old paths; `expected/` +contains the receipts used by this replay. The earlier layer-only audits +and returned-register controls are historical evidence. They are not +replay dependencies. The current runner executes the 166 basis checks +in sequence; the preserved historical scheduler used three workers. +Python child processes ignore Python environment options so their +assertions remain enabled. + +## Open next questions + +Does an eight-call clean circuit exist in frame span five or six outside +the two excluded scalar classes? A first step is an exact completeness +reduction for the remaining nonzero active off-diagonal patterns. The +present reductions do not bound that full scalar search. A positive word +would still need an all-size compiler and a full cost calculation before +it could affect kappa. diff --git a/research/bit-clean-extra-register/SOURCE-MANIFEST.json b/research/bit-clean-extra-register/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..924bd8d9e7 --- /dev/null +++ b/research/bit-clean-extra-register/SOURCE-MANIFEST.json @@ -0,0 +1,143 @@ +{ + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "original": "work/doubling-architecture/clean-ancilla/ALL-BASIS-SUMMARY.json", + "package": "expected/all-basis-summary.json", + "sha256": "46040fe7a442e117f9a28ce47caa53d3800ca45777a9bfb16463fc58125b1a4a", + "bytes": 64174 + }, + { + "original": "work/doubling-architecture/rank-independent/clean-audit/CATALOGUE-AUDIT.json", + "package": "expected/catalogue-audit.json", + "sha256": "5034f22651597e8710498194a185543735d2cdfd1d65b62b554045b1516638c8", + "bytes": 1493 + }, + { + "original": "work/four-register/independent-audit/CLEAN-ZERO-ORDER-RESULT.json", + "package": "expected/clean-zero-independent-order-result.json", + "sha256": "7dcd340eedf19388a4a2db364be4a00388e93a38ab4d08d7729971c88d1d2632", + "bytes": 178 + }, + { + "original": "work/four-register/independent/clean-zero/RESULT.json", + "package": "expected/clean-zero-result.json", + "sha256": "b8ce3ecf7bd762cfb9a2bfaa37f0dbd0034eba42ad59bb68e714c4d220c2d997", + "bytes": 2031 + }, + { + "original": "work/doubling-architecture/rank-independent/clean-audit/SELECTED-COMPARISON.json", + "package": "expected/selected-comparison.json", + "sha256": "5f0e29bb04fd0f44267237060728dfb8bca2e1f41181c940f30fe0ae8c2cee39", + "bytes": 37045 + }, + { + "original": "work/doubling-architecture/clean-ancilla/ALPHABETS.txt", + "package": "sources/doubling-architecture/clean-ancilla/ALPHABETS.txt", + "sha256": "9578ac3ba047a87502cc6e481f5bf8154f1c2477f3be4b2d1e7c1e8b35213da4", + "bytes": 5868 + }, + { + "original": "work/doubling-architecture/clean-ancilla/RESULT.txt", + "package": "sources/doubling-architecture/clean-ancilla/RESULT.txt", + "sha256": "bddf6f4a91273966179f36fd59734c125f2bad69d10ed27998595da438aa2c73", + "bytes": 3768 + }, + { + "original": "work/doubling-architecture/clean-ancilla/run_two_bases.py", + "package": "sources/doubling-architecture/clean-ancilla/run_two_bases.py", + "sha256": "33ac757f42b7e770d24ea82b70cc167627e28b1da98c1e0c8c5d0e35f9bb2931", + "bytes": 1748 + }, + { + "original": "work/doubling-architecture/clean-ancilla/search.py", + "package": "sources/doubling-architecture/clean-ancilla/search.py", + "sha256": "3f1301263134b1ed17d356f39bdd175f911c2c4cdddb5e3cab40fed6969e53bf", + "bytes": 3762 + }, + { + "original": "work/doubling-architecture/clean-ancilla/two_bases.cpp", + "package": "sources/doubling-architecture/clean-ancilla/two_bases.cpp", + "sha256": "7d7438f5c473eba5a0863afacdb7b0896b2c45325cf2f88c7cfb078d189ff132", + "bytes": 15146 + }, + { + "original": "work/doubling-architecture/rank-independent/clean-audit/PROOF-AUDIT.txt", + "package": "sources/doubling-architecture/rank-independent/clean-audit/PROOF-AUDIT.txt", + "sha256": "92f039fd3868592bc8cfa3b14ea90f42c5be9ed639ca84ac6ce7a6cb5fc59e5b", + "bytes": 7629 + }, + { + "original": "work/doubling-architecture/rank-independent/clean-audit/selected_words.cpp", + "package": "sources/doubling-architecture/rank-independent/clean-audit/selected_words.cpp", + "sha256": "bd5ee927c75a78ce4658d2290dd4301c78744178c2b95b3fe676153dae2a2fa0", + "bytes": 778 + }, + { + "original": "work/four-register/CLEAN-ONE-RELATION.txt", + "package": "sources/four-register/CLEAN-ONE-RELATION.txt", + "sha256": "9aebe7497d3ff594141ab1674bc34284c6cc410f2d066994ff8c059c940902e6", + "bytes": 6804 + }, + { + "original": "work/four-register/CLEAN-SPAN-FOUR.txt", + "package": "sources/four-register/CLEAN-SPAN-FOUR.txt", + "sha256": "a65edc9dfe3744322a4fad5f30d2d0c7fb737bb611f5b11de48264386e742019", + "bytes": 3817 + }, + { + "original": "work/four-register/F101-ARITHMETIC.txt", + "package": "sources/four-register/F101-ARITHMETIC.txt", + "sha256": "540dfa9f49488b92ee24e9f82704ac2032aa2117957dd4c9cbcf33ca4fafe09f", + "bytes": 3513 + }, + { + "original": "work/four-register/FINAL-CLEAN-REPORT.txt", + "package": "sources/four-register/FINAL-CLEAN-REPORT.txt", + "sha256": "a948c7380e22ff83030811c9e6b5a867b510609c89ee0b586feb7616374e748c", + "bytes": 6492 + }, + { + "original": "work/four-register/dirty_ancilla.py", + "package": "sources/four-register/dirty_ancilla.py", + "sha256": "81d8df0b7b08e0ad89dc13f65325e7091cb9c201d9c5bc4d8637f8325d0be876", + "bytes": 6293 + }, + { + "original": "work/four-register/independent-audit/check_clean_zero_orders.cpp", + "package": "sources/four-register/independent-audit/check_clean_zero_orders.cpp", + "sha256": "488f25346635fdebac5b0d928da59dabe0c92792d375938b5dfe1c2244309d6a", + "bytes": 4419 + }, + { + "original": "work/four-register/independent-audit/clean-zero-family-metadata.txt", + "package": "sources/four-register/independent-audit/clean-zero-family-metadata.txt", + "sha256": "6e4758a04985074fc78aca9a55aecff947573b66803d26f5f4d7676a30dd8dd7", + "bytes": 8410 + }, + { + "original": "work/four-register/independent/clean-zero/PROOF.txt", + "package": "sources/four-register/independent/clean-zero/PROOF.txt", + "sha256": "4dea498aee7f2e39a0607b6d4f1e7f8f9f7ad9a5f1e72241743180f1775fb7e7", + "bytes": 5049 + }, + { + "original": "work/four-register/independent/clean-zero/field.cpp", + "package": "sources/four-register/independent/clean-zero/field.cpp", + "sha256": "a39b5f3ca6dbd506c6008e356a0239173e8dff53047c4a6e71972c6c35226c9e", + "bytes": 13395 + }, + { + "original": "work/four-register/independent/clean-zero/generate.py", + "package": "sources/four-register/independent/clean-zero/generate.py", + "sha256": "f002f6479e244da91724ca2589c03c4067d82f2206304660a92f8355dfedb6ef", + "bytes": 2088 + }, + { + "original": "work/four-register/independent/clean-zero/integer.cpp", + "package": "sources/four-register/independent/clean-zero/integer.cpp", + "sha256": "927fcb11154edfeabfdf852c0f243f82b7d5d56475ced11bdaa3417b8528b6d9", + "bytes": 13367 + } + ] +} diff --git a/research/bit-clean-extra-register/expected/all-basis-summary.json b/research/bit-clean-extra-register/expected/all-basis-summary.json new file mode 100644 index 0000000000..7462d3d1c9 --- /dev/null +++ b/research/bit-clean-extra-register/expected/all-basis-summary.json @@ -0,0 +1,3170 @@ +{ + "alphabets": 166, + "completed": 166, + "searched_words": 7406643, + "states": [ + 7406643, + 24410375, + 59745229, + 89537683 + ], + "terminals": 262735, + "robust": 0, + "seconds": 90.62961008306593, + "results": [ + { + "basis": 0, + "alphabet_size": 4, + "complete": true, + "prefixes": 247, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 7.292e-06 + }, + { + "basis": 1, + "alphabet_size": 6, + "complete": true, + "prefixes": 6430, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 8.9e-05 + }, + { + "basis": 2, + "alphabet_size": 6, + "complete": true, + "prefixes": 6394, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 9.1e-05 + }, + { + "basis": 3, + "alphabet_size": 6, + "complete": true, + "prefixes": 10138, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 9.6125e-05 + }, + { + "basis": 4, + "alphabet_size": 7, + "complete": true, + "prefixes": 36949, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000306292 + }, + { + "basis": 5, + "alphabet_size": 7, + "complete": true, + "prefixes": 26542, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00024525 + }, + { + "basis": 6, + "alphabet_size": 7, + "complete": true, + "prefixes": 22471, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000197917 + }, + { + "basis": 7, + "alphabet_size": 7, + "complete": true, + "prefixes": 32309, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000272417 + }, + { + "basis": 8, + "alphabet_size": 7, + "complete": true, + "prefixes": 26769, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000250125 + }, + { + "basis": 9, + "alphabet_size": 7, + "complete": true, + "prefixes": 35985, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000309708 + }, + { + "basis": 10, + "alphabet_size": 7, + "complete": true, + "prefixes": 32233, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.0002995 + }, + { + "basis": 11, + "alphabet_size": 7, + "complete": true, + "prefixes": 36781, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000305667 + }, + { + "basis": 12, + "alphabet_size": 7, + "complete": true, + "prefixes": 52509, + "distance_trace_words": 253, + "searched_words": 253, + "states": [ + 253, + 523, + 685, + 605 + ], + "terminals": 73, + "robust": 0, + "parity_prunes": 489, + "zero_frame_prunes": 521, + "seconds": 0.00256767 + }, + { + "basis": 13, + "alphabet_size": 7, + "complete": true, + "prefixes": 35384, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000298375 + }, + { + "basis": 14, + "alphabet_size": 7, + "complete": true, + "prefixes": 22152, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000263791 + }, + { + "basis": 15, + "alphabet_size": 7, + "complete": true, + "prefixes": 50649, + "distance_trace_words": 178, + "searched_words": 178, + "states": [ + 178, + 426, + 622, + 546 + ], + "terminals": 51, + "robust": 0, + "parity_prunes": 446, + "zero_frame_prunes": 415, + "seconds": 0.00202275 + }, + { + "basis": 16, + "alphabet_size": 8, + "complete": true, + "prefixes": 45857, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000408666 + }, + { + "basis": 17, + "alphabet_size": 8, + "complete": true, + "prefixes": 44001, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000397291 + }, + { + "basis": 18, + "alphabet_size": 7, + "complete": true, + "prefixes": 153529, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15940, + 23364 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18077, + "zero_frame_prunes": 11722, + "seconds": 0.0524807 + }, + { + "basis": 19, + "alphabet_size": 8, + "complete": true, + "prefixes": 471272, + "distance_trace_words": 16086, + "searched_words": 16086, + "states": [ + 16086, + 30568, + 31974, + 43063 + ], + "terminals": 2638, + "robust": 0, + "parity_prunes": 31348, + "zero_frame_prunes": 23964, + "seconds": 0.121799 + }, + { + "basis": 20, + "alphabet_size": 8, + "complete": true, + "prefixes": 254809, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15940, + 23364 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18077, + "zero_frame_prunes": 11722, + "seconds": 0.0538696 + }, + { + "basis": 21, + "alphabet_size": 8, + "complete": true, + "prefixes": 120944, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00113446 + }, + { + "basis": 22, + "alphabet_size": 8, + "complete": true, + "prefixes": 332933, + "distance_trace_words": 4842, + "searched_words": 4842, + "states": [ + 4842, + 7642, + 7378, + 10676 + ], + "terminals": 1085, + "robust": 0, + "parity_prunes": 7558, + "zero_frame_prunes": 6689, + "seconds": 0.02834 + }, + { + "basis": 23, + "alphabet_size": 8, + "complete": true, + "prefixes": 323024, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15940, + 23364 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18077, + "zero_frame_prunes": 11722, + "seconds": 0.0525706 + }, + { + "basis": 24, + "alphabet_size": 8, + "complete": true, + "prefixes": 332017, + "distance_trace_words": 10689, + "searched_words": 10689, + "states": [ + 10689, + 21441, + 22894, + 32132 + ], + "terminals": 1668, + "robust": 0, + "parity_prunes": 23605, + "zero_frame_prunes": 16462, + "seconds": 0.0807185 + }, + { + "basis": 25, + "alphabet_size": 8, + "complete": true, + "prefixes": 182126, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00161154 + }, + { + "basis": 26, + "alphabet_size": 7, + "complete": true, + "prefixes": 79205, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000735583 + }, + { + "basis": 27, + "alphabet_size": 8, + "complete": true, + "prefixes": 252437, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00226054 + }, + { + "basis": 28, + "alphabet_size": 8, + "complete": true, + "prefixes": 141679, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00129408 + }, + { + "basis": 29, + "alphabet_size": 8, + "complete": true, + "prefixes": 135229, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00120708 + }, + { + "basis": 30, + "alphabet_size": 8, + "complete": true, + "prefixes": 140522, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00135388 + }, + { + "basis": 31, + "alphabet_size": 8, + "complete": true, + "prefixes": 224770, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00220412 + }, + { + "basis": 32, + "alphabet_size": 8, + "complete": true, + "prefixes": 139751, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00134504 + }, + { + "basis": 33, + "alphabet_size": 8, + "complete": true, + "prefixes": 194597, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.001729 + }, + { + "basis": 34, + "alphabet_size": 8, + "complete": true, + "prefixes": 309405, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15891, + 23345 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18091, + "zero_frame_prunes": 11722, + "seconds": 0.0530179 + }, + { + "basis": 35, + "alphabet_size": 8, + "complete": true, + "prefixes": 608513, + "distance_trace_words": 28187, + "searched_words": 28187, + "states": [ + 28187, + 59701, + 43046, + 22759 + ], + "terminals": 846, + "robust": 0, + "parity_prunes": 68115, + "zero_frame_prunes": 24655, + "seconds": 0.135025 + }, + { + "basis": 36, + "alphabet_size": 8, + "complete": true, + "prefixes": 506547, + "distance_trace_words": 29138, + "searched_words": 29138, + "states": [ + 29138, + 56290, + 38410, + 20447 + ], + "terminals": 958, + "robust": 0, + "parity_prunes": 55737, + "zero_frame_prunes": 28463, + "seconds": 0.123861 + }, + { + "basis": 37, + "alphabet_size": 8, + "complete": true, + "prefixes": 302715, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15940, + 23364 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18077, + "zero_frame_prunes": 11722, + "seconds": 0.056236 + }, + { + "basis": 38, + "alphabet_size": 8, + "complete": true, + "prefixes": 179046, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00155671 + }, + { + "basis": 39, + "alphabet_size": 8, + "complete": true, + "prefixes": 78020, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000744667 + }, + { + "basis": 40, + "alphabet_size": 8, + "complete": true, + "prefixes": 443443, + "distance_trace_words": 19184, + "searched_words": 19184, + "states": [ + 19184, + 40814, + 34158, + 22355 + ], + "terminals": 672, + "robust": 0, + "parity_prunes": 54132, + "zero_frame_prunes": 14251, + "seconds": 0.103835 + }, + { + "basis": 41, + "alphabet_size": 7, + "complete": true, + "prefixes": 76823, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000711917 + }, + { + "basis": 42, + "alphabet_size": 8, + "complete": true, + "prefixes": 195129, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00166512 + }, + { + "basis": 43, + "alphabet_size": 8, + "complete": true, + "prefixes": 133570, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00121142 + }, + { + "basis": 44, + "alphabet_size": 7, + "complete": true, + "prefixes": 153529, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16214, + 21733 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18130, + "zero_frame_prunes": 12167, + "seconds": 0.048632 + }, + { + "basis": 45, + "alphabet_size": 8, + "complete": true, + "prefixes": 376397, + "distance_trace_words": 15159, + "searched_words": 15159, + "states": [ + 15159, + 26485, + 23944, + 30052 + ], + "terminals": 2050, + "robust": 0, + "parity_prunes": 23235, + "zero_frame_prunes": 22131, + "seconds": 0.0931108 + }, + { + "basis": 46, + "alphabet_size": 8, + "complete": true, + "prefixes": 257500, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16214, + 21733 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18130, + "zero_frame_prunes": 12167, + "seconds": 0.052392 + }, + { + "basis": 47, + "alphabet_size": 8, + "complete": true, + "prefixes": 270599, + "distance_trace_words": 7350, + "searched_words": 7350, + "states": [ + 7350, + 15040, + 13100, + 18274 + ], + "terminals": 2464, + "robust": 0, + "parity_prunes": 14339, + "zero_frame_prunes": 11755, + "seconds": 0.0478829 + }, + { + "basis": 48, + "alphabet_size": 8, + "complete": true, + "prefixes": 300860, + "distance_trace_words": 4692, + "searched_words": 4692, + "states": [ + 4692, + 7034, + 3295, + 2069 + ], + "terminals": 282, + "robust": 0, + "parity_prunes": 4079, + "zero_frame_prunes": 4504, + "seconds": 0.016373 + }, + { + "basis": 49, + "alphabet_size": 8, + "complete": true, + "prefixes": 311196, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16214, + 21733 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18130, + "zero_frame_prunes": 12165, + "seconds": 0.0533703 + }, + { + "basis": 50, + "alphabet_size": 8, + "complete": true, + "prefixes": 408201, + "distance_trace_words": 12792, + "searched_words": 12792, + "states": [ + 12792, + 24590, + 24325, + 31633 + ], + "terminals": 1859, + "robust": 0, + "parity_prunes": 25193, + "zero_frame_prunes": 19475, + "seconds": 0.0928714 + }, + { + "basis": 51, + "alphabet_size": 8, + "complete": true, + "prefixes": 424852, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00456558 + }, + { + "basis": 52, + "alphabet_size": 8, + "complete": true, + "prefixes": 325248, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16173, + 21798 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18209, + "zero_frame_prunes": 12086, + "seconds": 0.0548922 + }, + { + "basis": 53, + "alphabet_size": 8, + "complete": true, + "prefixes": 495293, + "distance_trace_words": 26789, + "searched_words": 26789, + "states": [ + 26789, + 44955, + 31154, + 16203 + ], + "terminals": 764, + "robust": 0, + "parity_prunes": 41386, + "zero_frame_prunes": 25902, + "seconds": 0.110991 + }, + { + "basis": 54, + "alphabet_size": 8, + "complete": true, + "prefixes": 293616, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16214, + 21733 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18130, + "zero_frame_prunes": 12167, + "seconds": 0.0510114 + }, + { + "basis": 55, + "alphabet_size": 8, + "complete": true, + "prefixes": 187421, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.001909 + }, + { + "basis": 56, + "alphabet_size": 8, + "complete": true, + "prefixes": 591397, + "distance_trace_words": 25952, + "searched_words": 25952, + "states": [ + 25952, + 45984, + 31337, + 17858 + ], + "terminals": 526, + "robust": 0, + "parity_prunes": 50736, + "zero_frame_prunes": 17366, + "seconds": 0.119533 + }, + { + "basis": 57, + "alphabet_size": 8, + "complete": true, + "prefixes": 72247, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000669542 + }, + { + "basis": 58, + "alphabet_size": 8, + "complete": true, + "prefixes": 159758, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00140663 + }, + { + "basis": 59, + "alphabet_size": 8, + "complete": true, + "prefixes": 85095, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000877292 + }, + { + "basis": 60, + "alphabet_size": 8, + "complete": true, + "prefixes": 121381, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.0011145 + }, + { + "basis": 61, + "alphabet_size": 8, + "complete": true, + "prefixes": 140778, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00122887 + }, + { + "basis": 62, + "alphabet_size": 8, + "complete": true, + "prefixes": 196100, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00166487 + }, + { + "basis": 63, + "alphabet_size": 8, + "complete": true, + "prefixes": 353651, + "distance_trace_words": 8570, + "searched_words": 8570, + "states": [ + 8570, + 16542, + 21816, + 19617 + ], + "terminals": 1242, + "robust": 0, + "parity_prunes": 14058, + "zero_frame_prunes": 17344, + "seconds": 0.0764972 + }, + { + "basis": 64, + "alphabet_size": 8, + "complete": true, + "prefixes": 298669, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.002551 + }, + { + "basis": 65, + "alphabet_size": 8, + "complete": true, + "prefixes": 154924, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00130846 + }, + { + "basis": 66, + "alphabet_size": 8, + "complete": true, + "prefixes": 547663, + "distance_trace_words": 17513, + "searched_words": 17513, + "states": [ + 17513, + 36077, + 50078, + 51904 + ], + "terminals": 1432, + "robust": 0, + "parity_prunes": 34739, + "zero_frame_prunes": 35895, + "seconds": 0.153209 + }, + { + "basis": 67, + "alphabet_size": 8, + "complete": true, + "prefixes": 130325, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00110187 + }, + { + "basis": 68, + "alphabet_size": 8, + "complete": true, + "prefixes": 262299, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15940, + 23364 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18077, + "zero_frame_prunes": 11722, + "seconds": 0.0535562 + }, + { + "basis": 69, + "alphabet_size": 8, + "complete": true, + "prefixes": 406856, + "distance_trace_words": 12366, + "searched_words": 12366, + "states": [ + 12366, + 23938, + 24774, + 34196 + ], + "terminals": 1906, + "robust": 0, + "parity_prunes": 25289, + "zero_frame_prunes": 18580, + "seconds": 0.0911052 + }, + { + "basis": 70, + "alphabet_size": 8, + "complete": true, + "prefixes": 214013, + "distance_trace_words": 3258, + "searched_words": 3258, + "states": [ + 3258, + 6638, + 2512, + 1072 + ], + "terminals": 260, + "robust": 0, + "parity_prunes": 5270, + "zero_frame_prunes": 2649, + "seconds": 0.0114845 + }, + { + "basis": 71, + "alphabet_size": 8, + "complete": true, + "prefixes": 187512, + "distance_trace_words": 1791, + "searched_words": 1791, + "states": [ + 1791, + 2927, + 2781, + 4141 + ], + "terminals": 633, + "robust": 0, + "parity_prunes": 3287, + "zero_frame_prunes": 2504, + "seconds": 0.0108207 + }, + { + "basis": 72, + "alphabet_size": 8, + "complete": true, + "prefixes": 304769, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 15940, + 23364 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18077, + "zero_frame_prunes": 11722, + "seconds": 0.0545414 + }, + { + "basis": 73, + "alphabet_size": 8, + "complete": true, + "prefixes": 511724, + "distance_trace_words": 14172, + "searched_words": 14172, + "states": [ + 14172, + 28044, + 31131, + 42528 + ], + "terminals": 2406, + "robust": 0, + "parity_prunes": 29955, + "zero_frame_prunes": 22009, + "seconds": 0.114236 + }, + { + "basis": 74, + "alphabet_size": 8, + "complete": true, + "prefixes": 256798, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00225033 + }, + { + "basis": 75, + "alphabet_size": 8, + "complete": true, + "prefixes": 196307, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00186204 + }, + { + "basis": 76, + "alphabet_size": 8, + "complete": true, + "prefixes": 224198, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00205296 + }, + { + "basis": 77, + "alphabet_size": 8, + "complete": true, + "prefixes": 161748, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00151217 + }, + { + "basis": 78, + "alphabet_size": 8, + "complete": true, + "prefixes": 430737, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00362967 + }, + { + "basis": 79, + "alphabet_size": 8, + "complete": true, + "prefixes": 310736, + "distance_trace_words": 4692, + "searched_words": 4692, + "states": [ + 4692, + 7034, + 3095, + 2269 + ], + "terminals": 282, + "robust": 0, + "parity_prunes": 4225, + "zero_frame_prunes": 4563, + "seconds": 0.0173155 + }, + { + "basis": 80, + "alphabet_size": 8, + "complete": true, + "prefixes": 344351, + "distance_trace_words": 8786, + "searched_words": 8786, + "states": [ + 8786, + 16470, + 12400, + 6654 + ], + "terminals": 450, + "robust": 0, + "parity_prunes": 18259, + "zero_frame_prunes": 8183, + "seconds": 0.0394754 + }, + { + "basis": 81, + "alphabet_size": 8, + "complete": true, + "prefixes": 628859, + "distance_trace_words": 31955, + "searched_words": 31955, + "states": [ + 31955, + 52633, + 27830, + 14611 + ], + "terminals": 836, + "robust": 0, + "parity_prunes": 43215, + "zero_frame_prunes": 27444, + "seconds": 0.119754 + }, + { + "basis": 82, + "alphabet_size": 8, + "complete": true, + "prefixes": 189383, + "distance_trace_words": 1791, + "searched_words": 1791, + "states": [ + 1791, + 2927, + 2731, + 4172 + ], + "terminals": 633, + "robust": 0, + "parity_prunes": 3276, + "zero_frame_prunes": 2556, + "seconds": 0.012149 + }, + { + "basis": 83, + "alphabet_size": 8, + "complete": true, + "prefixes": 259274, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00231875 + }, + { + "basis": 84, + "alphabet_size": 8, + "complete": true, + "prefixes": 136300, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00121333 + }, + { + "basis": 85, + "alphabet_size": 8, + "complete": true, + "prefixes": 322788, + "distance_trace_words": 6458, + "searched_words": 6458, + "states": [ + 6458, + 11890, + 9565, + 6350 + ], + "terminals": 426, + "robust": 0, + "parity_prunes": 15733, + "zero_frame_prunes": 4324, + "seconds": 0.0311112 + }, + { + "basis": 86, + "alphabet_size": 8, + "complete": true, + "prefixes": 142817, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00131862 + }, + { + "basis": 87, + "alphabet_size": 8, + "complete": true, + "prefixes": 178835, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00157625 + }, + { + "basis": 88, + "alphabet_size": 8, + "complete": true, + "prefixes": 129418, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00112888 + }, + { + "basis": 89, + "alphabet_size": 8, + "complete": true, + "prefixes": 262299, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16214, + 21733 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18130, + "zero_frame_prunes": 12167, + "seconds": 0.0508378 + }, + { + "basis": 90, + "alphabet_size": 8, + "complete": true, + "prefixes": 576701, + "distance_trace_words": 19947, + "searched_words": 19947, + "states": [ + 19947, + 33295, + 28991, + 35511 + ], + "terminals": 2685, + "robust": 0, + "parity_prunes": 26753, + "zero_frame_prunes": 28261, + "seconds": 0.11562 + }, + { + "basis": 91, + "alphabet_size": 8, + "complete": true, + "prefixes": 533118, + "distance_trace_words": 15606, + "searched_words": 15606, + "states": [ + 15606, + 30436, + 17298, + 7095 + ], + "terminals": 262, + "robust": 0, + "parity_prunes": 30655, + "zero_frame_prunes": 11446, + "seconds": 0.0575915 + }, + { + "basis": 92, + "alphabet_size": 8, + "complete": true, + "prefixes": 486983, + "distance_trace_words": 12975, + "searched_words": 12975, + "states": [ + 12975, + 25563, + 22329, + 31513 + ], + "terminals": 4445, + "robust": 0, + "parity_prunes": 24782, + "zero_frame_prunes": 19716, + "seconds": 0.081875 + }, + { + "basis": 93, + "alphabet_size": 8, + "complete": true, + "prefixes": 457384, + "distance_trace_words": 10056, + "searched_words": 10056, + "states": [ + 10056, + 15434, + 8207, + 5274 + ], + "terminals": 244, + "robust": 0, + "parity_prunes": 10916, + "zero_frame_prunes": 9167, + "seconds": 0.0365525 + }, + { + "basis": 94, + "alphabet_size": 8, + "complete": true, + "prefixes": 314524, + "distance_trace_words": 7776, + "searched_words": 7776, + "states": [ + 7776, + 15804, + 16214, + 21733 + ], + "terminals": 1063, + "robust": 0, + "parity_prunes": 18130, + "zero_frame_prunes": 12165, + "seconds": 0.0508495 + }, + { + "basis": 95, + "alphabet_size": 8, + "complete": true, + "prefixes": 405898, + "distance_trace_words": 10326, + "searched_words": 10326, + "states": [ + 10326, + 20282, + 20408, + 26817 + ], + "terminals": 1432, + "robust": 0, + "parity_prunes": 21779, + "zero_frame_prunes": 15929, + "seconds": 0.075366 + }, + { + "basis": 96, + "alphabet_size": 8, + "complete": true, + "prefixes": 297028, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00248825 + }, + { + "basis": 97, + "alphabet_size": 8, + "complete": true, + "prefixes": 345093, + "distance_trace_words": 4842, + "searched_words": 4842, + "states": [ + 4842, + 7642, + 7323, + 9959 + ], + "terminals": 1085, + "robust": 0, + "parity_prunes": 7568, + "zero_frame_prunes": 6912, + "seconds": 0.0287489 + }, + { + "basis": 98, + "alphabet_size": 8, + "complete": true, + "prefixes": 627997, + "distance_trace_words": 28901, + "searched_words": 28901, + "states": [ + 28901, + 56583, + 51932, + 33658 + ], + "terminals": 1048, + "robust": 0, + "parity_prunes": 65600, + "zero_frame_prunes": 33783, + "seconds": 0.16176 + }, + { + "basis": 99, + "alphabet_size": 8, + "complete": true, + "prefixes": 459048, + "distance_trace_words": 10056, + "searched_words": 10056, + "states": [ + 10056, + 15434, + 7907, + 5101 + ], + "terminals": 244, + "robust": 0, + "parity_prunes": 11744, + "zero_frame_prunes": 8660, + "seconds": 0.0367094 + }, + { + "basis": 100, + "alphabet_size": 8, + "complete": true, + "prefixes": 152476, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00133608 + }, + { + "basis": 101, + "alphabet_size": 8, + "complete": true, + "prefixes": 610657, + "distance_trace_words": 28349, + "searched_words": 28349, + "states": [ + 28349, + 59089, + 53197, + 35275 + ], + "terminals": 850, + "robust": 0, + "parity_prunes": 76425, + "zero_frame_prunes": 25853, + "seconds": 0.155945 + }, + { + "basis": 102, + "alphabet_size": 8, + "complete": true, + "prefixes": 467779, + "distance_trace_words": 16086, + "searched_words": 16086, + "states": [ + 16086, + 30568, + 31078, + 42468 + ], + "terminals": 2638, + "robust": 0, + "parity_prunes": 31277, + "zero_frame_prunes": 23981, + "seconds": 0.111836 + }, + { + "basis": 103, + "alphabet_size": 8, + "complete": true, + "prefixes": 251557, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.0021795 + }, + { + "basis": 104, + "alphabet_size": 8, + "complete": true, + "prefixes": 609424, + "distance_trace_words": 28187, + "searched_words": 28187, + "states": [ + 28187, + 59701, + 43557, + 22894 + ], + "terminals": 846, + "robust": 0, + "parity_prunes": 68432, + "zero_frame_prunes": 24766, + "seconds": 0.136461 + }, + { + "basis": 105, + "alphabet_size": 8, + "complete": true, + "prefixes": 507978, + "distance_trace_words": 29138, + "searched_words": 29138, + "states": [ + 29138, + 56290, + 37737, + 20357 + ], + "terminals": 958, + "robust": 0, + "parity_prunes": 55816, + "zero_frame_prunes": 28559, + "seconds": 0.125586 + }, + { + "basis": 106, + "alphabet_size": 8, + "complete": true, + "prefixes": 212980, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00181313 + }, + { + "basis": 107, + "alphabet_size": 8, + "complete": true, + "prefixes": 329564, + "distance_trace_words": 10689, + "searched_words": 10689, + "states": [ + 10689, + 21441, + 22346, + 31721 + ], + "terminals": 1668, + "robust": 0, + "parity_prunes": 23659, + "zero_frame_prunes": 16469, + "seconds": 0.0811424 + }, + { + "basis": 108, + "alphabet_size": 8, + "complete": true, + "prefixes": 117532, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00109258 + }, + { + "basis": 109, + "alphabet_size": 8, + "complete": true, + "prefixes": 444388, + "distance_trace_words": 19184, + "searched_words": 19184, + "states": [ + 19184, + 40814, + 34330, + 22323 + ], + "terminals": 672, + "robust": 0, + "parity_prunes": 54312, + "zero_frame_prunes": 14507, + "seconds": 0.276678 + }, + { + "basis": 110, + "alphabet_size": 7, + "complete": true, + "prefixes": 379035, + "distance_trace_words": 111458, + "searched_words": 111458, + "states": [ + 111458, + 520248, + 3105586, + 4813364 + ], + "terminals": 5701, + "robust": 0, + "parity_prunes": 6347096, + "zero_frame_prunes": 271448, + "seconds": 11.1845 + }, + { + "basis": 111, + "alphabet_size": 8, + "complete": true, + "prefixes": 1009277, + "distance_trace_words": 188468, + "searched_words": 188468, + "states": [ + 188468, + 758034, + 3856027, + 5384857 + ], + "terminals": 10285, + "robust": 0, + "parity_prunes": 7340617, + "zero_frame_prunes": 429513, + "seconds": 13.2823 + }, + { + "basis": 112, + "alphabet_size": 8, + "complete": true, + "prefixes": 1000400, + "distance_trace_words": 188468, + "searched_words": 188468, + "states": [ + 188468, + 758034, + 3852305, + 5392460 + ], + "terminals": 10285, + "robust": 0, + "parity_prunes": 7327941, + "zero_frame_prunes": 430290, + "seconds": 13.138 + }, + { + "basis": 113, + "alphabet_size": 8, + "complete": true, + "prefixes": 807757, + "distance_trace_words": 165053, + "searched_words": 165053, + "states": [ + 165053, + 695027, + 3666446, + 5173966 + ], + "terminals": 8816, + "robust": 0, + "parity_prunes": 7048749, + "zero_frame_prunes": 382690, + "seconds": 12.6337 + }, + { + "basis": 114, + "alphabet_size": 8, + "complete": true, + "prefixes": 789288, + "distance_trace_words": 161633, + "searched_words": 161633, + "states": [ + 161633, + 685385, + 3647854, + 5187215 + ], + "terminals": 8844, + "robust": 0, + "parity_prunes": 7053651, + "zero_frame_prunes": 375821, + "seconds": 12.7702 + }, + { + "basis": 115, + "alphabet_size": 8, + "complete": true, + "prefixes": 1209709, + "distance_trace_words": 198752, + "searched_words": 198752, + "states": [ + 198752, + 523068, + 342474, + 186843 + ], + "terminals": 2740, + "robust": 0, + "parity_prunes": 692830, + "zero_frame_prunes": 155858, + "seconds": 1.3389 + }, + { + "basis": 116, + "alphabet_size": 8, + "complete": true, + "prefixes": 912137, + "distance_trace_words": 141510, + "searched_words": 141510, + "states": [ + 141510, + 671246, + 1008704, + 2310885 + ], + "terminals": 2448, + "robust": 0, + "parity_prunes": 2929648, + "zero_frame_prunes": 202239, + "seconds": 5.82108 + }, + { + "basis": 117, + "alphabet_size": 8, + "complete": true, + "prefixes": 369783, + "distance_trace_words": 15159, + "searched_words": 15159, + "states": [ + 15159, + 26485, + 24029, + 30708 + ], + "terminals": 2050, + "robust": 0, + "parity_prunes": 22362, + "zero_frame_prunes": 21894, + "seconds": 0.0969896 + }, + { + "basis": 118, + "alphabet_size": 8, + "complete": true, + "prefixes": 795977, + "distance_trace_words": 165053, + "searched_words": 165053, + "states": [ + 165053, + 695027, + 3656379, + 5220003 + ], + "terminals": 8816, + "robust": 0, + "parity_prunes": 7061483, + "zero_frame_prunes": 386498, + "seconds": 12.9951 + }, + { + "basis": 119, + "alphabet_size": 8, + "complete": true, + "prefixes": 1208198, + "distance_trace_words": 198752, + "searched_words": 198752, + "states": [ + 198752, + 523068, + 325262, + 179396 + ], + "terminals": 2740, + "robust": 0, + "parity_prunes": 675663, + "zero_frame_prunes": 151158, + "seconds": 1.40057 + }, + { + "basis": 120, + "alphabet_size": 8, + "complete": true, + "prefixes": 915184, + "distance_trace_words": 141510, + "searched_words": 141510, + "states": [ + 141510, + 671246, + 1009532, + 2308775 + ], + "terminals": 2448, + "robust": 0, + "parity_prunes": 2934453, + "zero_frame_prunes": 199057, + "seconds": 5.86077 + }, + { + "basis": 121, + "alphabet_size": 8, + "complete": true, + "prefixes": 387376, + "distance_trace_words": 12366, + "searched_words": 12366, + "states": [ + 12366, + 23938, + 24820, + 33663 + ], + "terminals": 1906, + "robust": 0, + "parity_prunes": 25138, + "zero_frame_prunes": 18699, + "seconds": 0.0968898 + }, + { + "basis": 122, + "alphabet_size": 8, + "complete": true, + "prefixes": 767363, + "distance_trace_words": 161633, + "searched_words": 161633, + "states": [ + 161633, + 685385, + 3646287, + 5212409 + ], + "terminals": 8844, + "robust": 0, + "parity_prunes": 7056789, + "zero_frame_prunes": 376796, + "seconds": 12.9496 + }, + { + "basis": 123, + "alphabet_size": 8, + "complete": true, + "prefixes": 563318, + "distance_trace_words": 19947, + "searched_words": 19947, + "states": [ + 19947, + 33295, + 29036, + 36202 + ], + "terminals": 2685, + "robust": 0, + "parity_prunes": 25665, + "zero_frame_prunes": 27972, + "seconds": 0.125944 + }, + { + "basis": 124, + "alphabet_size": 8, + "complete": true, + "prefixes": 1013250, + "distance_trace_words": 195236, + "searched_words": 195236, + "states": [ + 195236, + 783378, + 504266, + 397372 + ], + "terminals": 1937, + "robust": 0, + "parity_prunes": 1274531, + "zero_frame_prunes": 166262, + "seconds": 1.98803 + }, + { + "basis": 125, + "alphabet_size": 8, + "complete": true, + "prefixes": 1002732, + "distance_trace_words": 132714, + "searched_words": 132714, + "states": [ + 132714, + 313578, + 222860, + 96132 + ], + "terminals": 2291, + "robust": 0, + "parity_prunes": 393754, + "zero_frame_prunes": 100996, + "seconds": 0.831249 + }, + { + "basis": 126, + "alphabet_size": 8, + "complete": true, + "prefixes": 989482, + "distance_trace_words": 196644, + "searched_words": 196644, + "states": [ + 196644, + 670438, + 822613, + 2088941 + ], + "terminals": 5049, + "robust": 0, + "parity_prunes": 2523478, + "zero_frame_prunes": 235679, + "seconds": 5.52093 + }, + { + "basis": 127, + "alphabet_size": 8, + "complete": true, + "prefixes": 604220, + "distance_trace_words": 28901, + "searched_words": 28901, + "states": [ + 28901, + 56583, + 49690, + 32892 + ], + "terminals": 1048, + "robust": 0, + "parity_prunes": 63300, + "zero_frame_prunes": 34522, + "seconds": 0.161888 + }, + { + "basis": 128, + "alphabet_size": 8, + "complete": true, + "prefixes": 329186, + "distance_trace_words": 8786, + "searched_words": 8786, + "states": [ + 8786, + 16470, + 12054, + 6610 + ], + "terminals": 450, + "robust": 0, + "parity_prunes": 17677, + "zero_frame_prunes": 8172, + "seconds": 0.0418768 + }, + { + "basis": 129, + "alphabet_size": 8, + "complete": true, + "prefixes": 738815, + "distance_trace_words": 90072, + "searched_words": 90072, + "states": [ + 90072, + 272444, + 235537, + 237656 + ], + "terminals": 2007, + "robust": 0, + "parity_prunes": 536828, + "zero_frame_prunes": 72812, + "seconds": 0.935067 + }, + { + "basis": 130, + "alphabet_size": 8, + "complete": true, + "prefixes": 1078051, + "distance_trace_words": 157083, + "searched_words": 157083, + "states": [ + 157083, + 606135, + 1106891, + 2402071 + ], + "terminals": 2928, + "robust": 0, + "parity_prunes": 2991451, + "zero_frame_prunes": 194632, + "seconds": 7.11736 + }, + { + "basis": 131, + "alphabet_size": 8, + "complete": true, + "prefixes": 1007516, + "distance_trace_words": 189596, + "searched_words": 189596, + "states": [ + 189596, + 758448, + 3806506, + 5273624 + ], + "terminals": 10257, + "robust": 0, + "parity_prunes": 7210333, + "zero_frame_prunes": 425303, + "seconds": 17.0533 + }, + { + "basis": 132, + "alphabet_size": 8, + "complete": true, + "prefixes": 959946, + "distance_trace_words": 180128, + "searched_words": 180128, + "states": [ + 180128, + 758034, + 3923422, + 5398917 + ], + "terminals": 10657, + "robust": 0, + "parity_prunes": 7428503, + "zero_frame_prunes": 415850, + "seconds": 17.3969 + }, + { + "basis": 133, + "alphabet_size": 8, + "complete": true, + "prefixes": 1569622, + "distance_trace_words": 288201, + "searched_words": 288201, + "states": [ + 288201, + 760813, + 425802, + 220004 + ], + "terminals": 3555, + "robust": 0, + "parity_prunes": 897440, + "zero_frame_prunes": 245968, + "seconds": 2.91932 + }, + { + "basis": 134, + "alphabet_size": 8, + "complete": true, + "prefixes": 486146, + "distance_trace_words": 26789, + "searched_words": 26789, + "states": [ + 26789, + 44955, + 29021, + 18045 + ], + "terminals": 764, + "robust": 0, + "parity_prunes": 40593, + "zero_frame_prunes": 26251, + "seconds": 0.170809 + }, + { + "basis": 135, + "alphabet_size": 8, + "complete": true, + "prefixes": 1030452, + "distance_trace_words": 199652, + "searched_words": 199652, + "states": [ + 199652, + 842588, + 1542853, + 3291576 + ], + "terminals": 3165, + "robust": 0, + "parity_prunes": 4277449, + "zero_frame_prunes": 234753, + "seconds": 10.1792 + }, + { + "basis": 136, + "alphabet_size": 8, + "complete": true, + "prefixes": 1428866, + "distance_trace_words": 207640, + "searched_words": 207640, + "states": [ + 207640, + 365094, + 287508, + 142341 + ], + "terminals": 2973, + "robust": 0, + "parity_prunes": 448670, + "zero_frame_prunes": 130246, + "seconds": 1.37757 + }, + { + "basis": 137, + "alphabet_size": 8, + "complete": true, + "prefixes": 1101359, + "distance_trace_words": 157083, + "searched_words": 157083, + "states": [ + 157083, + 606135, + 1112236, + 2491821 + ], + "terminals": 2928, + "robust": 0, + "parity_prunes": 3071994, + "zero_frame_prunes": 195547, + "seconds": 7.66311 + }, + { + "basis": 138, + "alphabet_size": 8, + "complete": true, + "prefixes": 329930, + "distance_trace_words": 8570, + "searched_words": 8570, + "states": [ + 8570, + 16542, + 21252, + 20478 + ], + "terminals": 1242, + "robust": 0, + "parity_prunes": 13365, + "zero_frame_prunes": 17434, + "seconds": 0.0892843 + }, + { + "basis": 139, + "alphabet_size": 8, + "complete": true, + "prefixes": 596000, + "distance_trace_words": 31955, + "searched_words": 31955, + "states": [ + 31955, + 52633, + 26841, + 14213 + ], + "terminals": 836, + "robust": 0, + "parity_prunes": 42797, + "zero_frame_prunes": 27446, + "seconds": 0.154969 + }, + { + "basis": 140, + "alphabet_size": 8, + "complete": true, + "prefixes": 1047004, + "distance_trace_words": 143276, + "searched_words": 143276, + "states": [ + 143276, + 302206, + 192197, + 84699 + ], + "terminals": 1574, + "robust": 0, + "parity_prunes": 363017, + "zero_frame_prunes": 87733, + "seconds": 1.01706 + }, + { + "basis": 141, + "alphabet_size": 8, + "complete": true, + "prefixes": 1415074, + "distance_trace_words": 207640, + "searched_words": 207640, + "states": [ + 207640, + 365094, + 277005, + 145592 + ], + "terminals": 2973, + "robust": 0, + "parity_prunes": 455477, + "zero_frame_prunes": 132088, + "seconds": 1.45665 + }, + { + "basis": 142, + "alphabet_size": 8, + "complete": true, + "prefixes": 405217, + "distance_trace_words": 12792, + "searched_words": 12792, + "states": [ + 12792, + 24590, + 23851, + 32956 + ], + "terminals": 1859, + "robust": 0, + "parity_prunes": 25884, + "zero_frame_prunes": 19295, + "seconds": 0.117597 + }, + { + "basis": 143, + "alphabet_size": 8, + "complete": true, + "prefixes": 271167, + "distance_trace_words": 7350, + "searched_words": 7350, + "states": [ + 7350, + 15040, + 13201, + 17916 + ], + "terminals": 2464, + "robust": 0, + "parity_prunes": 14344, + "zero_frame_prunes": 11515, + "seconds": 0.0649482 + }, + { + "basis": 144, + "alphabet_size": 8, + "complete": true, + "prefixes": 591397, + "distance_trace_words": 25952, + "searched_words": 25952, + "states": [ + 25952, + 45984, + 31072, + 18318 + ], + "terminals": 526, + "robust": 0, + "parity_prunes": 50135, + "zero_frame_prunes": 17317, + "seconds": 0.152294 + }, + { + "basis": 145, + "alphabet_size": 8, + "complete": true, + "prefixes": 987173, + "distance_trace_words": 189596, + "searched_words": 189596, + "states": [ + 189596, + 758448, + 3796674, + 5368562 + ], + "terminals": 10257, + "robust": 0, + "parity_prunes": 7301356, + "zero_frame_prunes": 431748, + "seconds": 15.4444 + }, + { + "basis": 146, + "alphabet_size": 8, + "complete": true, + "prefixes": 816137, + "distance_trace_words": 269666, + "searched_words": 269666, + "states": [ + 269666, + 1394614, + 2343734, + 4921413 + ], + "terminals": 5058, + "robust": 0, + "parity_prunes": 6683770, + "zero_frame_prunes": 315026, + "seconds": 14.1255 + }, + { + "basis": 147, + "alphabet_size": 8, + "complete": true, + "prefixes": 1004123, + "distance_trace_words": 132714, + "searched_words": 132714, + "states": [ + 132714, + 313578, + 217881, + 92150 + ], + "terminals": 2291, + "robust": 0, + "parity_prunes": 387113, + "zero_frame_prunes": 102993, + "seconds": 0.964867 + }, + { + "basis": 148, + "alphabet_size": 8, + "complete": true, + "prefixes": 719807, + "distance_trace_words": 87488, + "searched_words": 87488, + "states": [ + 87488, + 194356, + 140849, + 72493 + ], + "terminals": 1726, + "robust": 0, + "parity_prunes": 263505, + "zero_frame_prunes": 49721, + "seconds": 0.610453 + }, + { + "basis": 149, + "alphabet_size": 8, + "complete": true, + "prefixes": 1551935, + "distance_trace_words": 288201, + "searched_words": 288201, + "states": [ + 288201, + 760813, + 412598, + 211095 + ], + "terminals": 3555, + "robust": 0, + "parity_prunes": 876903, + "zero_frame_prunes": 242577, + "seconds": 2.03426 + }, + { + "basis": 150, + "alphabet_size": 8, + "complete": true, + "prefixes": 988044, + "distance_trace_words": 196644, + "searched_words": 196644, + "states": [ + 196644, + 670438, + 828077, + 2106490 + ], + "terminals": 5049, + "robust": 0, + "parity_prunes": 2539266, + "zero_frame_prunes": 237701, + "seconds": 6.31674 + }, + { + "basis": 151, + "alphabet_size": 8, + "complete": true, + "prefixes": 1599386, + "distance_trace_words": 309953, + "searched_words": 309953, + "states": [ + 309953, + 1191517, + 1700093, + 2953851 + ], + "terminals": 3676, + "robust": 0, + "parity_prunes": 4358402, + "zero_frame_prunes": 272700, + "seconds": 9.37422 + }, + { + "basis": 152, + "alphabet_size": 8, + "complete": true, + "prefixes": 395300, + "distance_trace_words": 10326, + "searched_words": 10326, + "states": [ + 10326, + 20282, + 19722, + 28592 + ], + "terminals": 1432, + "robust": 0, + "parity_prunes": 21567, + "zero_frame_prunes": 15530, + "seconds": 0.092499 + }, + { + "basis": 153, + "alphabet_size": 8, + "complete": true, + "prefixes": 211155, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00234929 + }, + { + "basis": 154, + "alphabet_size": 8, + "complete": true, + "prefixes": 922759, + "distance_trace_words": 180128, + "searched_words": 180128, + "states": [ + 180128, + 758034, + 3918407, + 5421376 + ], + "terminals": 10657, + "robust": 0, + "parity_prunes": 7427637, + "zero_frame_prunes": 416983, + "seconds": 15.2938 + }, + { + "basis": 155, + "alphabet_size": 8, + "complete": true, + "prefixes": 116344, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.00130204 + }, + { + "basis": 156, + "alphabet_size": 8, + "complete": true, + "prefixes": 493917, + "distance_trace_words": 14172, + "searched_words": 14172, + "states": [ + 14172, + 28044, + 31068, + 38033 + ], + "terminals": 2406, + "robust": 0, + "parity_prunes": 29795, + "zero_frame_prunes": 23292, + "seconds": 0.127875 + }, + { + "basis": 157, + "alphabet_size": 8, + "complete": true, + "prefixes": 69771, + "distance_trace_words": 0, + "searched_words": 0, + "states": [ + 0, + 0, + 0, + 0 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 0, + "seconds": 0.000912916 + }, + { + "basis": 158, + "alphabet_size": 8, + "complete": true, + "prefixes": 484677, + "distance_trace_words": 12975, + "searched_words": 12975, + "states": [ + 12975, + 25563, + 23071, + 31006 + ], + "terminals": 4445, + "robust": 0, + "parity_prunes": 24748, + "zero_frame_prunes": 19403, + "seconds": 0.0994283 + }, + { + "basis": 159, + "alphabet_size": 8, + "complete": true, + "prefixes": 549016, + "distance_trace_words": 17513, + "searched_words": 17513, + "states": [ + 17513, + 36077, + 50398, + 50346 + ], + "terminals": 1432, + "robust": 0, + "parity_prunes": 32226, + "zero_frame_prunes": 36002, + "seconds": 0.193009 + }, + { + "basis": 160, + "alphabet_size": 8, + "complete": true, + "prefixes": 741354, + "distance_trace_words": 90072, + "searched_words": 90072, + "states": [ + 90072, + 272444, + 231423, + 235819 + ], + "terminals": 2007, + "robust": 0, + "parity_prunes": 532815, + "zero_frame_prunes": 73090, + "seconds": 1.11846 + }, + { + "basis": 161, + "alphabet_size": 8, + "complete": true, + "prefixes": 724728, + "distance_trace_words": 87488, + "searched_words": 87488, + "states": [ + 87488, + 194356, + 144418, + 73478 + ], + "terminals": 1726, + "robust": 0, + "parity_prunes": 266817, + "zero_frame_prunes": 49794, + "seconds": 0.58675 + }, + { + "basis": 162, + "alphabet_size": 8, + "complete": true, + "prefixes": 593966, + "distance_trace_words": 28349, + "searched_words": 28349, + "states": [ + 28349, + 59089, + 52317, + 33669 + ], + "terminals": 850, + "robust": 0, + "parity_prunes": 74892, + "zero_frame_prunes": 26521, + "seconds": 0.192436 + }, + { + "basis": 163, + "alphabet_size": 8, + "complete": true, + "prefixes": 312401, + "distance_trace_words": 6458, + "searched_words": 6458, + "states": [ + 6458, + 11890, + 9711, + 6447 + ], + "terminals": 426, + "robust": 0, + "parity_prunes": 15426, + "zero_frame_prunes": 4244, + "seconds": 0.0404735 + }, + { + "basis": 164, + "alphabet_size": 8, + "complete": true, + "prefixes": 1033668, + "distance_trace_words": 143276, + "searched_words": 143276, + "states": [ + 143276, + 302206, + 189604, + 81571 + ], + "terminals": 1574, + "robust": 0, + "parity_prunes": 360178, + "zero_frame_prunes": 86942, + "seconds": 0.927306 + }, + { + "basis": 165, + "alphabet_size": 8, + "complete": true, + "prefixes": 1561130, + "distance_trace_words": 309953, + "searched_words": 309953, + "states": [ + 309953, + 1191517, + 1667102, + 2806495 + ], + "terminals": 3676, + "robust": 0, + "parity_prunes": 4227628, + "zero_frame_prunes": 263222, + "seconds": 8.97335 + } + ] +} diff --git a/research/bit-clean-extra-register/expected/catalogue-audit.json b/research/bit-clean-extra-register/expected/catalogue-audit.json new file mode 100644 index 0000000000..eea310cd47 --- /dev/null +++ b/research/bit-clean-extra-register/expected/catalogue-audit.json @@ -0,0 +1,71 @@ +{ + "status": "PASS_CATALOGUE_FOR_DECLARED_THREE_SHAPES", + "unordered_binary_bases": 840, + "active_permutation_orbits": 166, + "basis_orbit_size_counts": { + "1": 6, + "3": 42, + "6": 118 + }, + "jobs": 17106, + "per_shape_distinct_jobs": { + "(2, 2, 2, 2)": 14148, + "(3, 3, 2)": 1479, + "(2, 3, 3)": 1479 + }, + "all_order_alphabet_file_exact_match": true, + "saved_search_record_coverage": 17106, + "saved_search_counts": { + "nodes": 114782, + "terminals": 656, + "low_rank_targets": 656, + "parity_prunes": 59249 + }, + "additional_shapes_counts": { + "(3, 2, 3)": 779, + "(4, 4)": 72 + }, + "additional_shape_jobs_outside_saved_catalogue": 851, + "additional_shape_jobs_also_outside_IH_scope": 831, + "valid_omitted_example_outside_IH_scope": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 1 + ], + [ + 14, + 14 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ] + ], + "source_sha256": { + "search.py": "3f1301263134b1ed17d356f39bdd175f911c2c4cdddb5e3cab40fed6969e53bf", + "bases.py": "bb931f93b113b8368031fbfc937d8cdf4e93da976dbb94cf00fe9cc4b78f690b", + "BASIS-JOBS.json": "ac55df3fe71b66ea8147d4992e7bfd7dbefd44577b165aaa2b173eeab9e2cb99", + "ALPHABETS.txt": "9578ac3ba047a87502cc6e481f5bf8154f1c2477f3be4b2d1e7c1e8b35213da4", + "BASIS-RESULTS.jsonl": "82fbacb98c45cdb42bb0c8c66816276ef4def6ea03f9b28d3724cf4a5b8e72b6" + } +} diff --git a/research/bit-clean-extra-register/expected/clean-zero-independent-order-result.json b/research/bit-clean-extra-register/expected/clean-zero-independent-order-result.json new file mode 100644 index 0000000000..ad88643d88 --- /dev/null +++ b/research/bit-clean-extra-register/expected/clean-zero-independent-order-result.json @@ -0,0 +1 @@ +{"status":"PASS_INDEPENDENT_CLEAN_ZERO_ORDER_COVERAGE","families":216,"raw_orders":3674160,"commutation_orders":314666,"binary_word_stream_identical":true,"reversal_used":false} diff --git a/research/bit-clean-extra-register/expected/clean-zero-result.json b/research/bit-clean-extra-register/expected/clean-zero-result.json new file mode 100644 index 0000000000..8885160551 --- /dev/null +++ b/research/bit-clean-extra-register/expected/clean-zero-result.json @@ -0,0 +1,46 @@ +{ + "status": "PASS_COMPLETE_ZERO_ACTIVE_OFF_PATTERN_CLEAN_CASE", + "alphabet_size": 24, + "multisets": 216, + "raw_orders": 3674160, + "commutation_orders": 314666, + "word_sha256": "07514db121efab4f9ccd5c64c4dfc6985e2345232890bad253f902d2e9ddadc0", + "engine_totals": { + "words": 314666, + "states": [ + 314666, + 1005125, + 1024411, + 2160151 + ], + "terminals": 20430, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 1612361 + }, + "all_chunk_totals_agree": true, + "all_terminal_word_and_counts_agree": true, + "terminal_word_count": 17799, + "source_and_result_sha256": { + "generate.py": "f002f6479e244da91724ca2589c03c4067d82f2206304660a92f8355dfedb6ef", + "catalogue.json": "08b253bec9189d5384d2867a4becd0cd2196150fc60c16db5ec0f1c00ecdd010", + "words.bin": "07514db121efab4f9ccd5c64c4dfc6985e2345232890bad253f902d2e9ddadc0", + "integer.cpp": "927fcb11154edfeabfdf852c0f243f82b7d5d56475ced11bdaa3417b8528b6d9", + "field.cpp": "a39b5f3ca6dbd506c6008e356a0239173e8dff53047c4a6e71972c6c35226c9e", + "integer-canonical-results.jsonl": "dd276858e3b033cc803667405b362ac10f89fb0fa0a67f01e6a7a208fce1bc98", + "field-results.jsonl": "dd276858e3b033cc803667405b362ac10f89fb0fa0a67f01e6a7a208fce1bc98", + "integer-canonical-results.jsonl.terminals.jsonl": "867a17bff3401105972153d20a1682de7c843177388b205ff76ba2782757c096", + "field-results.jsonl.terminals.jsonl": "867a17bff3401105972153d20a1682de7c843177388b205ff76ba2782757c096", + "PROOF.txt": "4dea498aee7f2e39a0607b6d4f1e7f8f9f7ad9a5f1e72241743180f1775fb7e7" + }, + "independent_front_end_audit": { + "status": "PASS_INDEPENDENT_CLEAN_ZERO_ORDER_COVERAGE", + "families": 216, + "raw_orders": 3674160, + "commutation_orders": 314666, + "binary_word_stream_identical": true, + "reversal_used": false + }, + "multiplicity_reduction": "Independent analytical proof and exact finite check agree", + "independent_front_end_receipt_sha256": "7dcd340eedf19388a4a2db364be4a00388e93a38ab4d08d7729971c88d1d2632" +} diff --git a/research/bit-clean-extra-register/expected/selected-comparison.json b/research/bit-clean-extra-register/expected/selected-comparison.json new file mode 100644 index 0000000000..c793196c2b --- /dev/null +++ b/research/bit-clean-extra-register/expected/selected-comparison.json @@ -0,0 +1,2648 @@ +{ + "status": "PASS_SELECTED_RATIONAL_FIELD_COMPARISON", + "cases": 48, + "selection": "24 nonsymmetric catalogue cases with the most terminals; 24 fixed-seed all-order words, with repeats permitted", + "scope": "Selected-case comparison, not a second full replay of all basis alphabets", + "results": [ + { + "case": 0, + "word": [ + [ + 1, + 9 + ], + [ + 6, + 10 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 9 + ], + [ + 11, + 6 + ], + [ + 15, + 14 + ] + ], + "fraction_stats": { + "nodes": 15, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 5 + }, + "fraction_survivors": 0, + "field": { + "case": 0, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 5, + 8, + 5 + ] + } + }, + { + "case": 1, + "word": [ + [ + 1, + 1 + ], + [ + 6, + 10 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 1 + ], + [ + 10, + 6 + ], + [ + 14, + 14 + ] + ], + "fraction_stats": { + "nodes": 14, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 4 + }, + "fraction_survivors": 0, + "field": { + "case": 1, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 5, + 7, + 5 + ] + } + }, + { + "case": 2, + "word": [ + [ + 3, + 13 + ], + [ + 11, + 15 + ], + [ + 12, + 4 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 9, + 3 + ], + [ + 12, + 4 + ] + ], + "fraction_stats": { + "nodes": 14, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 4 + }, + "fraction_survivors": 0, + "field": { + "case": 2, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 5, + 9, + 5 + ] + } + }, + { + "case": 3, + "word": [ + [ + 1, + 1 + ], + [ + 6, + 10 + ], + [ + 14, + 14 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 1 + ], + [ + 10, + 6 + ] + ], + "fraction_stats": { + "nodes": 13, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 3 + }, + "fraction_survivors": 0, + "field": { + "case": 3, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 5, + 8, + 5 + ] + } + }, + { + "case": 4, + "word": [ + [ + 1, + 3 + ], + [ + 3, + 6 + ], + [ + 7, + 12 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 3 + ], + [ + 15, + 8 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 4, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 5, + "word": [ + [ + 1, + 3 + ], + [ + 3, + 14 + ], + [ + 7, + 12 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 3 + ], + [ + 12, + 8 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 5, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 6, + "word": [ + [ + 1, + 11 + ], + [ + 3, + 6 + ], + [ + 7, + 12 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 11 + ], + [ + 14, + 8 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 6, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 7, + "word": [ + [ + 1, + 11 + ], + [ + 3, + 14 + ], + [ + 7, + 12 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 11 + ], + [ + 13, + 8 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 7, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 8, + "word": [ + [ + 3, + 1 + ], + [ + 8, + 12 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 3, + 1 + ], + [ + 12, + 7 + ], + [ + 14, + 3 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 8, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 9, + "word": [ + [ + 3, + 1 + ], + [ + 8, + 15 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 3, + 1 + ], + [ + 6, + 3 + ], + [ + 12, + 7 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 9, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 10, + "word": [ + [ + 3, + 5 + ], + [ + 10, + 7 + ], + [ + 13, + 4 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 8, + 11 + ], + [ + 13, + 4 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 10, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 11, + "word": [ + [ + 8, + 11 + ], + [ + 13, + 1 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 10, + 7 + ], + [ + 13, + 1 + ], + [ + 14, + 5 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 11, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 12, + "word": [ + [ + 9, + 7 + ], + [ + 11, + 6 + ], + [ + 14, + 4 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 8, + 13 + ], + [ + 14, + 4 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 12, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 13, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 1, + 5 + ], + [ + 10, + 8 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 5, + 14 + ], + [ + 7, + 10 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 13, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 14, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 1, + 5 + ], + [ + 15, + 8 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 5, + 6 + ], + [ + 7, + 10 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 14, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 15, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 1, + 7 + ], + [ + 3, + 10 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 5, + 12 + ], + [ + 14, + 8 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 15, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 16, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 1, + 13 + ], + [ + 11, + 8 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 5, + 14 + ], + [ + 7, + 10 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 16, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 17, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 1, + 13 + ], + [ + 14, + 8 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 5, + 6 + ], + [ + 7, + 10 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 17, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 18, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 1, + 15 + ], + [ + 3, + 10 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 5, + 12 + ], + [ + 15, + 8 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 18, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 19, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 5, + 1 + ], + [ + 8, + 15 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 6, + 5 + ], + [ + 10, + 7 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 19, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 20, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 5, + 1 + ], + [ + 8, + 10 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 10, + 7 + ], + [ + 14, + 5 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 20, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 21, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 5, + 6 + ], + [ + 7, + 10 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 1, + 5 + ], + [ + 15, + 8 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 21, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 22, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 5, + 6 + ], + [ + 7, + 10 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 1, + 13 + ], + [ + 14, + 8 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 22, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 23, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 5, + 6 + ], + [ + 9, + 7 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 6, + 2 + ], + [ + 8, + 15 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 2, + "low_rank_targets": 2, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 23, + "terminals": 2, + "robust": 0, + "states": [ + 1, + 1, + 3, + 2 + ] + } + }, + { + "case": 24, + "word": [ + [ + 6, + 12 + ], + [ + 15, + 7 + ], + [ + 6, + 12 + ], + [ + 3, + 9 + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ], + [ + 6, + 12 + ], + [ + 15, + 7 + ] + ], + "fraction_stats": { + "nodes": 3, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 2 + }, + "fraction_survivors": 0, + "field": { + "case": 24, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 3, + 0, + 0 + ] + } + }, + { + "case": 25, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 14 + ], + [ + 8, + 8 + ], + [ + 4, + 4 + ], + [ + 12, + 4 + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ], + [ + 8, + 8 + ] + ], + "fraction_stats": { + "nodes": 7, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 25, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 5, + 6, + 1 + ] + } + }, + { + "case": 26, + "word": [ + [ + 4, + 4 + ], + [ + 8, + 8 + ], + [ + 6, + 2 + ], + [ + 13, + 6 + ], + [ + 1, + 9 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 1, + 9 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 26, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 27, + "word": [ + [ + 8, + 12 + ], + [ + 8, + 8 + ], + [ + 3, + 1 + ], + [ + 8, + 8 + ], + [ + 8, + 12 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 14, + 3 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 27, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 28, + "word": [ + [ + 8, + 8 + ], + [ + 3, + 6 + ], + [ + 3, + 6 + ], + [ + 3, + 6 + ], + [ + 1, + 3 + ], + [ + 3, + 6 + ], + [ + 8, + 8 + ], + [ + 8, + 8 + ] + ], + "fraction_stats": { + "nodes": 2, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 28, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 1, + 0 + ] + } + }, + { + "case": 29, + "word": [ + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 8, + 8 + ], + [ + 1, + 1 + ], + [ + 8, + 8 + ], + [ + 4, + 12 + ], + [ + 4, + 4 + ], + [ + 2, + 10 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 1, + "low_rank_targets": 1, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 29, + "terminals": 1, + "robust": 0, + "states": [ + 1, + 0, + 0, + 0 + ] + } + }, + { + "case": 30, + "word": [ + [ + 1, + 11 + ], + [ + 1, + 11 + ], + [ + 7, + 2 + ], + [ + 8, + 8 + ], + [ + 9, + 14 + ], + [ + 7, + 2 + ], + [ + 9, + 14 + ], + [ + 1, + 11 + ] + ], + "fraction_stats": { + "nodes": 8, + "terminals": 1, + "low_rank_targets": 1, + "parity_prunes": 4 + }, + "fraction_survivors": 0, + "field": { + "case": 30, + "terminals": 1, + "robust": 0, + "states": [ + 1, + 1, + 5, + 1 + ] + } + }, + { + "case": 31, + "word": [ + [ + 2, + 2 + ], + [ + 4, + 6 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ], + [ + 8, + 8 + ], + [ + 4, + 6 + ], + [ + 1, + 3 + ], + [ + 4, + 4 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 31, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 32, + "word": [ + [ + 14, + 2 + ], + [ + 2, + 2 + ], + [ + 13, + 6 + ], + [ + 9, + 7 + ], + [ + 8, + 8 + ], + [ + 1, + 1 + ], + [ + 13, + 6 + ], + [ + 14, + 2 + ] + ], + "fraction_stats": { + "nodes": 6, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 2 + }, + "fraction_survivors": 0, + "field": { + "case": 32, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 3, + 2, + 3 + ] + } + }, + { + "case": 33, + "word": [ + [ + 4, + 14 + ], + [ + 4, + 4 + ], + [ + 4, + 14 + ], + [ + 11, + 8 + ], + [ + 4, + 14 + ], + [ + 1, + 1 + ], + [ + 7, + 10 + ], + [ + 8, + 8 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 33, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 34, + "word": [ + [ + 3, + 5 + ], + [ + 3, + 5 + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ], + [ + 10, + 8 + ], + [ + 10, + 8 + ], + [ + 10, + 8 + ], + [ + 10, + 8 + ] + ], + "fraction_stats": { + "nodes": 2, + "terminals": 1, + "low_rank_targets": 1, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 34, + "terminals": 1, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 35, + "word": [ + [ + 11, + 12 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ], + [ + 15, + 7 + ], + [ + 11, + 12 + ], + [ + 3, + 9 + ], + [ + 1, + 1 + ], + [ + 8, + 8 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 35, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 36, + "word": [ + [ + 1, + 11 + ], + [ + 1, + 11 + ], + [ + 1, + 1 + ], + [ + 8, + 8 + ], + [ + 1, + 1 + ], + [ + 14, + 14 + ], + [ + 7, + 10 + ], + [ + 1, + 1 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 36, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 37, + "word": [ + [ + 7, + 10 + ], + [ + 7, + 10 + ], + [ + 1, + 1 + ], + [ + 7, + 10 + ], + [ + 14, + 14 + ], + [ + 10, + 6 + ], + [ + 4, + 4 + ], + [ + 10, + 6 + ] + ], + "fraction_stats": { + "nodes": 5, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 3 + }, + "fraction_survivors": 0, + "field": { + "case": 37, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 3, + 0 + ] + } + }, + { + "case": 38, + "word": [ + [ + 11, + 11 + ], + [ + 4, + 4 + ], + [ + 14, + 9 + ], + [ + 4, + 4 + ], + [ + 9, + 7 + ], + [ + 2, + 2 + ], + [ + 14, + 9 + ], + [ + 13, + 13 + ] + ], + "fraction_stats": { + "nodes": 5, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 2 + }, + "fraction_survivors": 0, + "field": { + "case": 38, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 1, + 3 + ] + } + }, + { + "case": 39, + "word": [ + [ + 10, + 8 + ], + [ + 10, + 8 + ], + [ + 3, + 14 + ], + [ + 3, + 14 + ], + [ + 4, + 4 + ], + [ + 2, + 2 + ], + [ + 10, + 8 + ], + [ + 6, + 4 + ] + ], + "fraction_stats": { + "nodes": 2, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 39, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 1, + 0 + ] + } + }, + { + "case": 40, + "word": [ + [ + 8, + 8 + ], + [ + 15, + 14 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 2, + 2 + ], + [ + 4, + 4 + ], + [ + 1, + 3 + ], + [ + 2, + 2 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 40, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 41, + "word": [ + [ + 4, + 4 + ], + [ + 1, + 11 + ], + [ + 4, + 4 + ], + [ + 1, + 1 + ], + [ + 2, + 2 + ], + [ + 4, + 14 + ], + [ + 8, + 8 + ], + [ + 2, + 2 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 41, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 42, + "word": [ + [ + 1, + 1 + ], + [ + 8, + 8 + ], + [ + 8, + 8 + ], + [ + 2, + 14 + ], + [ + 12, + 4 + ], + [ + 8, + 8 + ], + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 42, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 43, + "word": [ + [ + 14, + 14 + ], + [ + 14, + 14 + ], + [ + 10, + 12 + ], + [ + 13, + 10 + ], + [ + 2, + 2 + ], + [ + 10, + 12 + ], + [ + 8, + 8 + ], + [ + 13, + 10 + ] + ], + "fraction_stats": { + "nodes": 4, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 3 + }, + "fraction_survivors": 0, + "field": { + "case": 43, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 3, + 0, + 0 + ] + } + }, + { + "case": 44, + "word": [ + [ + 3, + 1 + ], + [ + 10, + 3 + ], + [ + 8, + 15 + ], + [ + 12, + 4 + ], + [ + 8, + 8 + ], + [ + 3, + 1 + ], + [ + 10, + 3 + ], + [ + 1, + 1 + ] + ], + "fraction_stats": { + "nodes": 2, + "terminals": 1, + "low_rank_targets": 1, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 44, + "terminals": 1, + "robust": 0, + "states": [ + 1, + 1, + 0, + 0 + ] + } + }, + { + "case": 45, + "word": [ + [ + 13, + 4 + ], + [ + 11, + 12 + ], + [ + 4, + 4 + ], + [ + 4, + 4 + ], + [ + 1, + 1 + ], + [ + 1, + 7 + ], + [ + 1, + 7 + ], + [ + 11, + 12 + ] + ], + "fraction_stats": { + "nodes": 4, + "terminals": 0, + "low_rank_targets": 0, + "parity_prunes": 2 + }, + "fraction_survivors": 0, + "field": { + "case": 45, + "terminals": 0, + "robust": 0, + "states": [ + 1, + 1, + 3, + 0 + ] + } + }, + { + "case": 46, + "word": [ + [ + 1, + 15 + ], + [ + 1, + 15 + ], + [ + 10, + 6 + ], + [ + 15, + 14 + ], + [ + 1, + 1 + ], + [ + 10, + 6 + ], + [ + 6, + 10 + ], + [ + 8, + 8 + ] + ], + "fraction_stats": { + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 46, + "terminals": 1, + "robust": 0, + "states": [ + 1, + 1, + 1, + 1 + ] + } + }, + { + "case": 47, + "word": [ + [ + 14, + 8 + ], + [ + 14, + 8 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 2, + 10 + ], + [ + 1, + 1 + ], + [ + 4, + 4 + ], + [ + 14, + 8 + ] + ], + "fraction_stats": { + "nodes": 1, + "terminals": 1, + "low_rank_targets": 1, + "parity_prunes": 0 + }, + "fraction_survivors": 0, + "field": { + "case": 47, + "terminals": 1, + "robust": 0, + "states": [ + 1, + 0, + 0, + 0 + ] + } + } + ] +} diff --git a/research/bit-clean-extra-register/replay.log b/research/bit-clean-extra-register/replay.log new file mode 100644 index 0000000000..5900a083cc --- /dev/null +++ b/research/bit-clean-extra-register/replay.log @@ -0,0 +1,11 @@ +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/integer.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/integer +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/field.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/field +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent-audit/check_clean_zero_orders.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent-audit/orders +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/doubling-architecture/clean-ancilla/two_bases.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/doubling-architecture/clean-ancilla/two_bases +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/doubling-architecture/rank-independent/clean-audit/selected_words.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/doubling-architecture/rank-independent/clean-audit/selected_words +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/generate.py +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent-audit/orders /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent-audit/clean-zero-family-metadata.txt /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/words.bin +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/integer /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/words.bin /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/integer.jsonl +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/field /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/words.bin /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/four-register/independent/clean-zero/field.jsonl +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/clean-full/sources/doubling-architecture/clean-ancilla/run_two_bases.py +PASS_CLEAN_RESTRICTED_CLASSES 314666 7406643 diff --git a/research/bit-clean-extra-register/replayed-receipt.json b/research/bit-clean-extra-register/replayed-receipt.json new file mode 100644 index 0000000000..71c580ce5b --- /dev/null +++ b/research/bit-clean-extra-register/replayed-receipt.json @@ -0,0 +1,49 @@ +{ + "status": "PASS_CLEAN_RESTRICTED_CLASSES", + "clean_zero": { + "words": 314666, + "states": [ + 314666, + 1005125, + 1024411, + 2160151 + ], + "terminals": 20430, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 1612361 + }, + "independent_orders": { + "status": "PASS_INDEPENDENT_CLEAN_ZERO_ORDER_COVERAGE", + "families": 216, + "raw_orders": 3674160, + "commutation_orders": 314666, + "binary_word_stream_identical": true, + "reversal_used": false + }, + "basis_catalogue": { + "unordered_bases": 840, + "alphabets": 166, + "orbit_sizes": { + "1": 6, + "3": 42, + "6": 118 + } + }, + "all_basis": { + "alphabets": 166, + "completed": 166, + "searched_words": 7406643, + "states": [ + 7406643, + 24410375, + 59745229, + 89537683 + ], + "terminals": 262735, + "robust": 0 + }, + "selected_rational_field_words": 48, + "source_manifest_sha256": "f6936c24dcabf23a7d07e85fe1f098ba649a42913f4d545e6062a9de37fa1541", + "scope": "Restricted clean endpoint; frame spans five and six remain open." +} diff --git a/research/bit-clean-extra-register/review/REMOTE-PREDECESSORS.json b/research/bit-clean-extra-register/review/REMOTE-PREDECESSORS.json new file mode 100644 index 0000000000..b002faf532 --- /dev/null +++ b/research/bit-clean-extra-register/review/REMOTE-PREDECESSORS.json @@ -0,0 +1,26 @@ +{ + "pr203": { + "author": { + "id": "MDQ6VXNlcjU4MDc1ODUz", + "is_bot": false, + "login": "huxint", + "name": "huxint" + }, + "body": "Current paired-cube refinements leave substantial data-interface and copied-center costs in place. This research package proves explicit limits on several such continuations and tests a different small-network construction. **It reports no new multiplication exponent.**\n\nThe new statements are:\n\n- Keeping the pinned #193 complex or #187 bit data calls cannot reach kappa=0.01 even if every auxiliary call and all center loss are granted for free: the ordinary-saving ceilings are below 0.008867 and 0.008898.\n- A stated odd-dimensional paired-cube family remains below 0.008094 even with arbitrary local data chains and zero auxiliary entropy. The check includes an analytic infinite tail, not only a finite parameter scan.\n- For paired triples with p>=5, every nonzero linear combination of coordinate stars has binary source-support span at least h-2. Consequently any factorization through exactly h copied centers costs at least h(h-2); the current stars attain equality. Overcomplete center factors and different center implementations remain open.\n- A common triangular flag for every rational frame in the general finite bit contract forces s>=Wm. The argument also covers commuting frames whose common eigenbasis is not rational.\n- On all 87 chronological reuses of the balanced Fano model, every completed scalar permutation obtainable from local GL(2,F2) gates is routable. This extends the earlier fixed-terminal test to every auxiliary/data output permutation in this bounded family.\n\nOnly a self-contained research package and its workflow are added to main. Inputs from the unmerged supplier PRs are small pinned profiles; reproduction does not fetch or run those suppliers and does not enlarge their validation scope. The proofs state the interface assumptions and exclusions separately. Optional vector-code solver receipts are not used as independently checked impossibility certificates.\n\nValidation passed on a clean checkout based on main 3b6b668:\n\n```sh\npython -B -S research/percent-exponent-architecture/verify.py --deep\n```\n\nThis regenerates the rational ceilings, checks 59,048 nonzero finite center-coefficient controls and sharp examples, runs seven adverse/unit controls, exhausts the 87 scalar/routing cases in C++17, compares the matching algorithm with eight direct full-word enumerations, and independently replays all 16 retained-demand cases with Python. Verification leaves the checkout unchanged. CI repeats the exact package on Python 3.11 and 3.14.\n\nThe whole multiplication theorem remains conditional on its inherited analytic, all-size, precision, row and fixed-tape interfaces. The existing construction, supplier certificates and claimed kappa are unchanged.\n\nCredits and source hashes are in the package NOTICE and manifests, including the paired-cube/compiler authors, #193 and #187 suppliers, DaysSky's #192 entropy ceiling, romainhedouin's #183 assembly ceiling, and the repository's earlier Fano investigations. Prepared for huxint with substantial OpenAI Codex assistance.\n", + "headRefOid": "d2873e20750d0949d2ad75cbc4cd82b5b1a74e84", + "number": 203, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/203" + }, + "files": [ + { + "url": "https://github.com/huxint/integer-mult-bounds/blob/d2873e20750d0949d2ad75cbc4cd82b5b1a74e84/research/percent-exponent-architecture/PROOF.md", + "sha256": "b2830274450bcaa4fbc169e8a78a9b8f5d93c5ab41812a0216f33e0fdbd6d7a5", + "bytes": 16588 + }, + { + "url": "https://github.com/eumemic/integer-mult-bounds/blob/475a088b5862f75f0b10596cfd6842d19531a5ec/research/negative-results-paradigm-search/README.md", + "sha256": "c091e98c415e2a80bb28402b789363eb97dd3492061ca8875e421ae437de7482", + "bytes": 32216 + } + ] +} diff --git a/research/bit-clean-extra-register/review/REVIEW.json b/research/bit-clean-extra-register/review/REVIEW.json new file mode 100644 index 0000000000..18d7b5f377 --- /dev/null +++ b/research/bit-clean-extra-register/review/REVIEW.json @@ -0,0 +1,144 @@ +{ + "status": "APPROVED_SCOPED_RESULTS", + "timestamp_utc": "2026-10-23T04:09:53.766751+00:00", + "reviewer": "Independent OpenAI Codex agent /root/clean_register_review", + "human_review": false, + "proof_assistant_verification": false, + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "claims": [ + "Span at most four needs 3W calls with clean discarded workspace and lower-triangular invertible targets.", + "For eight calls, span eight is impossible; span seven forces zero active off-diagonal entries.", + "The complete 24-projector zero-active-off-pattern alphabet on four registers has no eight-call solution.", + "The coordinate-plus-one-basis alphabet on four registers has no eight-call solution." + ], + "fresh_replay": { + "status": "PASS_CLEAN_RESTRICTED_CLASSES", + "clean_zero": { + "words": 314666, + "states": [ + 314666, + 1005125, + 1024411, + 2160151 + ], + "terminals": 20430, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 1612361 + }, + "independent_orders": { + "status": "PASS_INDEPENDENT_CLEAN_ZERO_ORDER_COVERAGE", + "families": 216, + "raw_orders": 3674160, + "commutation_orders": 314666, + "binary_word_stream_identical": true, + "reversal_used": false + }, + "basis_catalogue": { + "unordered_bases": 840, + "alphabets": 166, + "orbit_sizes": { + "1": 6, + "3": 42, + "6": 118 + } + }, + "all_basis": { + "alphabets": 166, + "completed": 166, + "searched_words": 7406643, + "states": [ + 7406643, + 24410375, + 59745229, + 89537683 + ], + "terminals": 262735, + "robust": 0 + }, + "selected_rational_field_words": 48, + "source_manifest_sha256": "f6936c24dcabf23a7d07e85fe1f098ba649a42913f4d545e6062a9de37fa1541", + "scope": "Restricted clean endpoint; frame spans five and six remain open." + }, + "selected_fraction_and_field_terminal_count": 54, + "full_replay_matches_primary_receipt": true, + "controls": { + "status": "PASS_INDEPENDENT_CONTROLS", + "polynomial_engines": [ + { + "engine": "integer", + "output": "0 1 1\n1 1 0\n2 1 1\n3 0 0\n4 1 0\n", + "source_sha256": "927fcb11154edfeabfdf852c0f243f82b7d5d56475ced11bdaa3417b8528b6d9" + }, + { + "engine": "field", + "output": "0 1 1\n1 1 0\n2 1 1\n3 0 0\n4 1 0\n", + "source_sha256": "a39b5f3ca6dbd506c6008e356a0239173e8dff53047c4a6e71972c6c35226c9e" + } + ], + "fixture_scope": "Five polynomial fixtures; these are not paid-call circuit constructions.", + "fixtures": [ + "accept monomial targets of support three", + "reject a target of support two", + "accept after a required collision", + "reject a collision that forces a zero paid frame", + "reject a target reduced to a two-frame span" + ], + "optimized_python_rejected": true, + "source_corruption_rejected": true, + "child_optimization_environment_ignored": true + }, + "independent_reductions": { + "status": "PASS_INDEPENDENT_FINITE_REDUCTIONS", + "all_rank_one_idempotents": 120, + "zero_active_off_pattern_projectors": 24, + "distance_feasible_families": [ + { + "active_counts": [ + 2, + 2, + 2 + ], + "extra": [ + 7 + ] + } + ], + "active_rank_one_completion_patterns": { + "coordinate_plane": 6, + "coordinate_image_or_row": 6, + "unique": 16 + } + }, + "commands": [ + "python3 -B work/project-final-cleanup-20261022/early-projects-audit/packages/bit-clean-extra-register/verify.py --build work/project-final-cleanup-20261022/reviews/clean-register/replay", + "python3 -B work/project-final-cleanup-20261022/reviews/clean-register/check_reductions.py", + "python3 -B work/project-final-cleanup-20261022/reviews/clean-register/check_controls.py --package work/project-final-cleanup-20261022/early-projects-audit/packages/bit-clean-extra-register --build work/project-final-cleanup-20261022/reviews/clean-register/controls" + ], + "one_worker": true, + "full_replay_wrapper": { + "sha256": "ceb386dfda20481b46bf7fe638058f8a229ee23bf1b67c35247c74a52a692def", + "method": "Reconstructed from final wrapper by undoing the one later child-command change. Its child command matches replay.log.", + "final_sha256": "1d4df214f03e657ebf8de2ec2ebb9df405a3ed480fd10f255c0670b4f86ea54d", + "later_change": "Added -E -B to the Python generator child; frozen sources and mathematical checks did not change.", + "verification": "Final wrapper change received source review and an explicit PYTHONOPTIMIZE=2 isolation control. The complete census was not repeated for this command-only change." + }, + "resolved_findings": [ + "The portable runner now executes the 166 basis jobs in sequence.", + "README fixes the endpoint to the listed paid product and excludes an extra final free scalar map.", + "README retains precise PR203 credit; live attribution and pinned sources were checked.", + "README distinguishes relocated receipts from omitted historical layer-only and returned-register controls." + ], + "missing_material_inputs": [], + "limits": [ + "No exclusion of all clean-helper circuits. Frame spans five and six remain open in the stated model.", + "The full 7,406,643-word basis census has one arithmetic implementation. Only 48 selected words have Fraction corroboration.", + "The five new polynomial controls are not paid-call circuit constructions.", + "The final free scalar map is outside the contract.", + "No native supplier, complete kappa calculation, official frontier update, or human review is claimed." + ], + "kappa_improvement": false, + "publication_checks_remaining": [ + "Coordinator must verify final commit links and rendered PR description." + ] +} diff --git a/research/bit-clean-extra-register/review/REVIEW.md b/research/bit-clean-extra-register/review/REVIEW.md new file mode 100644 index 0000000000..77b3287257 --- /dev/null +++ b/research/bit-clean-extra-register/review/REVIEW.md @@ -0,0 +1,161 @@ +# Independent agent review: clean extra register + +Review scope: `bit-clean-extra-register`, in the publication staging area. +This review uses main commit `cef4b52f2a59009865bf8eabde1be3f159063703`. +The review is by a separate OpenAI Codex agent. It is not human review or +proof-assistant verification. The review did not start a new research search. + +## Claims reviewed + +The required endpoint is the upper-left active block of the product of paid +factors. There are three active inputs and one input set to zero. The fourth +output is not used. The three target frames are invertible, lower triangular +matrices over the rationals. Each paid address frame has nonzero rank one. +Each scalar coupling is a binary rank-one idempotent. + +The statements do not cover arbitrary final free scalar maps after the paid +product. In this endpoint model, augmentation fixes only the active block. +The full-endpoint argument that removes a final free scalar map in PR #468 +therefore cannot be imported without an additional proof. + +The written and finite results are: + +1. Paid-frame span at most four needs at least `3W` calls for `W` invertible + lower-triangular targets, with any finite number of zero input registers + whose outputs are not used. +2. Eight independent paid frames cannot serve three such targets. At span + seven, every scalar projector has zero active off-diagonal entries. +3. For one extra register, all 24 projectors with that zero pattern are + excluded at eight calls. +4. For one extra register, the union of the coordinate-basis projectors and + one arbitrary binary basis is excluded at eight calls. + +These results do not exclude all eight-call circuits with a clean input. +Frame spans five and six, a nonzero active off-diagonal pattern, and an +alphabet outside the coordinate-plus-one-basis class remain open here. +The package gives no complete supplier, new construction, or new kappa. + +## Written proof checks + +The compact factorization `P-I=XTY^T` remains valid after compression to +the active block. The nonzero projected factors give an invertible triangular +`T` over the Laurent fraction field. If that block is zero, Sylvester's +inequality gives the stated sum of the two active ranks. No assertion about +the fourth row or column is needed. + +For the span-four reduction, the determinant expansion gives three paid +frames whose left vectors and right vectors are both independent. After +common row and column maps, the span has the form `D+tuv^T`. If `u` and `v` +have full support, the mixed minors force every rank-one member onto one +of the four basis lines. The sum of the projected active ranks gives `3W`. +Otherwise the directed support has blocks of size at most two. A rank-one +member has at most one nonzero diagonal block. The common rational flag of +the target ratios descends to each invariant subquotient. The compressed +two-dimensional flag bound and the one-dimensional rank bound then add to +`3W`. The lower-triangular target assumption is used in this step. + +For the one-relation reduction, a primitive relation with an entry of +absolute value at least two gives no subset collision. In the remaining +case, the Laurent kernel is principal. Its derivative forces one common +active off-diagonal pattern on the relation support and diagonal active +compressions elsewhere. The classification of rank-one completions covers +the unique matrix, coordinate-plane, and common coordinate image or row +cases. Deleting outside variables is valid because the only relation has +support in the retained variables. The variable assignments outside that +support are disjoint between target roles. The one- and two-target bounds +then give the claimed contradiction for every nonzero common pattern. + +The 24-projector classification uses all 120 binary rank-one idempotents +on four registers. The distance argument applies to both active image and +row codes even when the fourth output is discarded. If `d_i` counts the +three active-diagonal families, the necessary code distances force +`d=(2,2,2)` and one `(1,1,1)` helper contribution on each side. This gives +exactly the 216 stated multisets. The independent finite reconstruction +in `check_reductions.py` confirms this classification and all 28 nonzero +active rank-one completion patterns. + +The relation search branches only on differences of original subset +indicators. A nonzero off-diagonal term needs a collision. If a diagonal +has more than one term, at least one of its first two terms needs a partner. +Thus the reduced branching rule covers every possible monomial completion. +There are at most three independent relations after the span-four bound. +The zero-frame, primitive-parity, and target-in-two-frame-span rejections +are necessary conditions. Adding further relations cannot remove a target +rank obstruction already present at a terminal. + +The field engine's rational reconstruction box is injective modulo 101. +State rank tests use at most three bounded generators. Each additional +collision or target test has, after expansion along coordinate rows, at +most four nonunit rows with entries in `{-1,0,1}`. The Hadamard bound is 16, +so a nonzero relevant minor cannot vanish modulo 101. The two field cores +in `field.cpp` and `two_bases.cpp` are identical apart from blank lines. +Their reuse is not a second independent arithmetic implementation. + +The alphabet generator covers 840 unordered binary bases and 166 orbits +under permutations of the active coordinates. The helper coordinate stays +fixed. The independent dual-vector catalogue agrees with the saved rows. +Actual projector commutation preserves each formal factor word up to a +permutation of its paid-frame variables. The trace reduction keeps a least +representative of every class. No word-reversal reduction is used. Fixing +one basis to the coordinate basis is a restriction, not a normalization of +every pair of arbitrary bases. + +## Publication overlap and source checks + +All 23 entries in `SOURCE-MANIFEST.json` match both the package bytes and +their original local files. `SOURCE-REVIEW.json` records those checks, +the environment, the relevant current-main source hashes and the open-PR +snapshot hash. + +The current-main packages `bit-clean-ancilla-registers` and +`bit-clean-workspace-compression` require all auxiliary outputs on data +columns to return to zero. They do not cover the discarded-output contract +here. `bit-one-relation-any-registers` and +`bit-mixed-target-register-compression` require full dirty endpoints. +`three-register-no-target-flag` has no extra register. The four-register +rational-frame-floor result fixes a rank-two address alphabet and four +active targets. None is the submitted claim. A body search of the saved +open PRs found no matching clean-helper, discarded-output, zero-pattern, +or coordinate-plus-one-basis claim. The title matches #4931 and #3893 concern +a native prefix and a non-abelian S3 result, respectively. This is a check +against the stated snapshots, not a claim of literature priority. + +PR #468 is the material source for the formal model, span-four method and +exact relation search. Its pinned proof credits PR #288 for the scalar model +and flag/projection methods. It also credits PR #203 for the related +common-triangular-frame obstruction. Those credits must remain. +The source proof at `07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea` was read. +The pinned PR #288 and PR #203 proof sources were retrieved from GitHub and +their relevant sections were read. The PR #203 author and body both identify +`huxint`, and its live head matches the stated pin. `REMOTE-PREDECESSORS.json` +records the source hashes and that attribution evidence. Remote link rendering +and final PR-body checks belong to the coordinator. + +Historical prose names several paths that have moved to `expected/`. +The old 17,106-job layer census, its audit summary, and the returned-register +control script are not inputs to the new full replay. Their absence does +not leave a proof dependency missing. The runner generates the binary word +stream and the per-alphabet records from the included sources. + +## Requested corrections + +The first portable runner executed a historical three-worker driver. +The revised runner calls all 166 basis jobs in sequence and leaves that +historical source unchanged. The fresh review run uses the revised runner. +During that run, the author added `-E -B` to the Python generator child. +The completed census uses the preceding serial runner and the same frozen +sources. The final command change has a separate environment control; the +entire census was not repeated for this command-only change. + +The package author was asked to state the final-free-map restriction, +retain PR #203 credit, and explain the relocated and omitted historical +inputs. The final reviewed manifest records the files after those edits. + +## Execution record + +The final execution status, exact commands, control outcomes and package +hashes are recorded in `REVIEW.json` and `REVIEWED-FILES.json`. +The full two-engine census of the zero-pattern class is separate from the +single-engine full basis census. The 48 selected Fraction comparisons do +not constitute a second complete basis census. No supplier-native or +selected-frontier replay is required or claimed for these scoped results. diff --git a/research/bit-clean-extra-register/review/REVIEWED-FILES.json b/research/bit-clean-extra-register/review/REVIEWED-FILES.json new file mode 100644 index 0000000000..6b8b4f084e --- /dev/null +++ b/research/bit-clean-extra-register/review/REVIEWED-FILES.json @@ -0,0 +1,145 @@ +{ + "package": "bit-clean-extra-register", + "files": [ + { + "path": "README.md", + "bytes": 5268, + "sha256": "bebbd40548abb7b16c3cd83e8eab80c7ff1b2682e0c754103b3dc011b003cfe9" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 6211, + "sha256": "f6936c24dcabf23a7d07e85fe1f098ba649a42913f4d545e6062a9de37fa1541" + }, + { + "path": "expected/all-basis-summary.json", + "bytes": 64174, + "sha256": "46040fe7a442e117f9a28ce47caa53d3800ca45777a9bfb16463fc58125b1a4a" + }, + { + "path": "expected/catalogue-audit.json", + "bytes": 1493, + "sha256": "5034f22651597e8710498194a185543735d2cdfd1d65b62b554045b1516638c8" + }, + { + "path": "expected/clean-zero-independent-order-result.json", + "bytes": 178, + "sha256": "7dcd340eedf19388a4a2db364be4a00388e93a38ab4d08d7729971c88d1d2632" + }, + { + "path": "expected/clean-zero-result.json", + "bytes": 2031, + "sha256": "b8ce3ecf7bd762cfb9a2bfaa37f0dbd0034eba42ad59bb68e714c4d220c2d997" + }, + { + "path": "expected/selected-comparison.json", + "bytes": 37045, + "sha256": "5f0e29bb04fd0f44267237060728dfb8bca2e1f41181c940f30fe0ae8c2cee39" + }, + { + "path": "replay.log", + "bytes": 4285, + "sha256": "2438bd40f59c0f4cdbdc407cc67f92b13409ee5e56a2d2ba4244f6fe1a339c73" + }, + { + "path": "replayed-receipt.json", + "bytes": 1099, + "sha256": "5399fb71cdc4006275af5f63528bcf439d22edc64def24734cd19157932f768b" + }, + { + "path": "sources/doubling-architecture/clean-ancilla/ALPHABETS.txt", + "bytes": 5868, + "sha256": "9578ac3ba047a87502cc6e481f5bf8154f1c2477f3be4b2d1e7c1e8b35213da4" + }, + { + "path": "sources/doubling-architecture/clean-ancilla/RESULT.txt", + "bytes": 3768, + "sha256": "bddf6f4a91273966179f36fd59734c125f2bad69d10ed27998595da438aa2c73" + }, + { + "path": "sources/doubling-architecture/clean-ancilla/run_two_bases.py", + "bytes": 1748, + "sha256": "33ac757f42b7e770d24ea82b70cc167627e28b1da98c1e0c8c5d0e35f9bb2931" + }, + { + "path": "sources/doubling-architecture/clean-ancilla/search.py", + "bytes": 3762, + "sha256": "3f1301263134b1ed17d356f39bdd175f911c2c4cdddb5e3cab40fed6969e53bf" + }, + { + "path": "sources/doubling-architecture/clean-ancilla/two_bases.cpp", + "bytes": 15146, + "sha256": "7d7438f5c473eba5a0863afacdb7b0896b2c45325cf2f88c7cfb078d189ff132" + }, + { + "path": "sources/doubling-architecture/rank-independent/clean-audit/PROOF-AUDIT.txt", + "bytes": 7629, + "sha256": "92f039fd3868592bc8cfa3b14ea90f42c5be9ed639ca84ac6ce7a6cb5fc59e5b" + }, + { + "path": "sources/doubling-architecture/rank-independent/clean-audit/selected_words.cpp", + "bytes": 778, + "sha256": "bd5ee927c75a78ce4658d2290dd4301c78744178c2b95b3fe676153dae2a2fa0" + }, + { + "path": "sources/four-register/CLEAN-ONE-RELATION.txt", + "bytes": 6804, + "sha256": "9aebe7497d3ff594141ab1674bc34284c6cc410f2d066994ff8c059c940902e6" + }, + { + "path": "sources/four-register/CLEAN-SPAN-FOUR.txt", + "bytes": 3817, + "sha256": "a65edc9dfe3744322a4fad5f30d2d0c7fb737bb611f5b11de48264386e742019" + }, + { + "path": "sources/four-register/F101-ARITHMETIC.txt", + "bytes": 3513, + "sha256": "540dfa9f49488b92ee24e9f82704ac2032aa2117957dd4c9cbcf33ca4fafe09f" + }, + { + "path": "sources/four-register/FINAL-CLEAN-REPORT.txt", + "bytes": 6492, + "sha256": "a948c7380e22ff83030811c9e6b5a867b510609c89ee0b586feb7616374e748c" + }, + { + "path": "sources/four-register/dirty_ancilla.py", + "bytes": 6293, + "sha256": "81d8df0b7b08e0ad89dc13f65325e7091cb9c201d9c5bc4d8637f8325d0be876" + }, + { + "path": "sources/four-register/independent/clean-zero/PROOF.txt", + "bytes": 5049, + "sha256": "4dea498aee7f2e39a0607b6d4f1e7f8f9f7ad9a5f1e72241743180f1775fb7e7" + }, + { + "path": "sources/four-register/independent/clean-zero/field.cpp", + "bytes": 13395, + "sha256": "a39b5f3ca6dbd506c6008e356a0239173e8dff53047c4a6e71972c6c35226c9e" + }, + { + "path": "sources/four-register/independent/clean-zero/generate.py", + "bytes": 2088, + "sha256": "f002f6479e244da91724ca2589c03c4067d82f2206304660a92f8355dfedb6ef" + }, + { + "path": "sources/four-register/independent/clean-zero/integer.cpp", + "bytes": 13367, + "sha256": "927fcb11154edfeabfdf852c0f243f82b7d5d56475ced11bdaa3417b8528b6d9" + }, + { + "path": "sources/four-register/independent-audit/check_clean_zero_orders.cpp", + "bytes": 4419, + "sha256": "488f25346635fdebac5b0d928da59dabe0c92792d375938b5dfe1c2244309d6a" + }, + { + "path": "sources/four-register/independent-audit/clean-zero-family-metadata.txt", + "bytes": 8410, + "sha256": "6e4758a04985074fc78aca9a55aecff947573b66803d26f5f4d7676a30dd8dd7" + }, + { + "path": "verify.py", + "bytes": 8542, + "sha256": "1d4df214f03e657ebf8de2ec2ebb9df405a3ed480fd10f255c0670b4f86ea54d" + } + ] +} diff --git a/research/bit-clean-extra-register/review/SOURCE-REVIEW.json b/research/bit-clean-extra-register/review/SOURCE-REVIEW.json new file mode 100644 index 0000000000..e568d73ae3 --- /dev/null +++ b/research/bit-clean-extra-register/review/SOURCE-REVIEW.json @@ -0,0 +1,223 @@ +{ + "status": "PASS_SOURCE_BINDING", + "manifest_entries": [ + { + "package": "expected/all-basis-summary.json", + "recorded_sha256": "46040fe7a442e117f9a28ce47caa53d3800ca45777a9bfb16463fc58125b1a4a", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "expected/catalogue-audit.json", + "recorded_sha256": "5034f22651597e8710498194a185543735d2cdfd1d65b62b554045b1516638c8", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "expected/clean-zero-independent-order-result.json", + "recorded_sha256": "7dcd340eedf19388a4a2db364be4a00388e93a38ab4d08d7729971c88d1d2632", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "expected/clean-zero-result.json", + "recorded_sha256": "b8ce3ecf7bd762cfb9a2bfaa37f0dbd0034eba42ad59bb68e714c4d220c2d997", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "expected/selected-comparison.json", + "recorded_sha256": "5f0e29bb04fd0f44267237060728dfb8bca2e1f41181c940f30fe0ae8c2cee39", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/clean-ancilla/ALPHABETS.txt", + "recorded_sha256": "9578ac3ba047a87502cc6e481f5bf8154f1c2477f3be4b2d1e7c1e8b35213da4", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/clean-ancilla/RESULT.txt", + "recorded_sha256": "bddf6f4a91273966179f36fd59734c125f2bad69d10ed27998595da438aa2c73", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/clean-ancilla/run_two_bases.py", + "recorded_sha256": "33ac757f42b7e770d24ea82b70cc167627e28b1da98c1e0c8c5d0e35f9bb2931", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/clean-ancilla/search.py", + "recorded_sha256": "3f1301263134b1ed17d356f39bdd175f911c2c4cdddb5e3cab40fed6969e53bf", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/clean-ancilla/two_bases.cpp", + "recorded_sha256": "7d7438f5c473eba5a0863afacdb7b0896b2c45325cf2f88c7cfb078d189ff132", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/rank-independent/clean-audit/PROOF-AUDIT.txt", + "recorded_sha256": "92f039fd3868592bc8cfa3b14ea90f42c5be9ed639ca84ac6ce7a6cb5fc59e5b", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/doubling-architecture/rank-independent/clean-audit/selected_words.cpp", + "recorded_sha256": "bd5ee927c75a78ce4658d2290dd4301c78744178c2b95b3fe676153dae2a2fa0", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/CLEAN-ONE-RELATION.txt", + "recorded_sha256": "9aebe7497d3ff594141ab1674bc34284c6cc410f2d066994ff8c059c940902e6", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/CLEAN-SPAN-FOUR.txt", + "recorded_sha256": "a65edc9dfe3744322a4fad5f30d2d0c7fb737bb611f5b11de48264386e742019", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/F101-ARITHMETIC.txt", + "recorded_sha256": "540dfa9f49488b92ee24e9f82704ac2032aa2117957dd4c9cbcf33ca4fafe09f", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/FINAL-CLEAN-REPORT.txt", + "recorded_sha256": "a948c7380e22ff83030811c9e6b5a867b510609c89ee0b586feb7616374e748c", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/dirty_ancilla.py", + "recorded_sha256": "81d8df0b7b08e0ad89dc13f65325e7091cb9c201d9c5bc4d8637f8325d0be876", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/independent-audit/check_clean_zero_orders.cpp", + "recorded_sha256": "488f25346635fdebac5b0d928da59dabe0c92792d375938b5dfe1c2244309d6a", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/independent-audit/clean-zero-family-metadata.txt", + "recorded_sha256": "6e4758a04985074fc78aca9a55aecff947573b66803d26f5f4d7676a30dd8dd7", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/independent/clean-zero/PROOF.txt", + "recorded_sha256": "4dea498aee7f2e39a0607b6d4f1e7f8f9f7ad9a5f1e72241743180f1775fb7e7", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/independent/clean-zero/field.cpp", + "recorded_sha256": "a39b5f3ca6dbd506c6008e356a0239173e8dff53047c4a6e71972c6c35226c9e", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/independent/clean-zero/generate.py", + "recorded_sha256": "f002f6479e244da91724ca2589c03c4067d82f2206304660a92f8355dfedb6ef", + "package_matches": true, + "original_present": true, + "original_matches": true + }, + { + "package": "sources/four-register/independent/clean-zero/integer.cpp", + "recorded_sha256": "927fcb11154edfeabfdf852c0f243f82b7d5d56475ced11bdaa3417b8528b6d9", + "package_matches": true, + "original_present": true, + "original_matches": true + } + ], + "source_pins_reviewed": [ + { + "path": "research/bit-clean-ancilla-registers/README.md", + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sha256": "1e6aee0466e53ff5fb8dd130f2cd02a883e4cd95cf93ec7323ea333237c2d0e6" + }, + { + "path": "research/bit-clean-workspace-compression/README.md", + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sha256": "ca2cc91629ccb36475cd38f9d8c13719d3b2742d96080653b545a45b5d991885" + }, + { + "path": "research/bit-one-relation-any-registers/README.md", + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sha256": "1f2899320e646a4158531c3f8260ba32b4761ae883fdb5bce4d3e3b0a4d8cb8c" + }, + { + "path": "research/bit-four-register-rational-frame-floor-seed3573e12e/README.md", + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sha256": "40cbc4ec8e5c49930d7cb8ecf9e462a08266fe604ea426aa5c7b0d5e547fdffd" + }, + { + "path": "research/bit-mixed-target-register-compression/README.md", + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sha256": "0a937f6cbcc88718aa1b6b4be849883c331c54a392ce81dc3485ef10ddeedc39" + }, + { + "path": "research/three-register-no-target-flag/README.md", + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sha256": "95d4483da9b19df051c7d13fe290eefb82da019ab4be8e66ad9216199ddda4eb" + }, + { + "path": "research/bit-three-register-lower-bound/README.md", + "commit": "07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd" + } + ], + "open_pr_snapshot_sha256": "e0413ab0c3f982d9f35949478226b6617131708fae1469d49e3eb08e82a098e5", + "open_title_matches": [ + { + "number": 4931, + "title": "Expose a clean native prefix and construct one homogeneous U(q) offer (no new \u03ba)", + "headRefOid": "90a0124d306ef8802ac2dc3601c6705dca407e45", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4931" + }, + { + "number": 3893, + "title": "Add S3 three-register rank lower bound", + "headRefOid": "d3e2a4d5d967e9baf071dfdfe97e598aded3e025", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3893" + } + ], + "environment": { + "python": "3.14.7 (main, Aug 5 2026, 10:29:49) [Clang 21.0.0 (clang-2100.1.1.101)]", + "platform": "macOS-26.6.1-arm64-arm-64bit-Mach-O", + "compiler": "Apple clang version 17.0.0 (clang-1700.6.3.2)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin\n" + } +} diff --git a/research/bit-clean-extra-register/review/check_controls.py b/research/bit-clean-extra-register/review/check_controls.py new file mode 100644 index 0000000000..e6c417de53 --- /dev/null +++ b/research/bit-clean-extra-register/review/check_controls.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Check acceptance and rejection paths without changing saved sources.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys + + +def require(value, message): + if not value: + raise ValueError(message) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--package", type=Path, required=True) + parser.add_argument("--build", type=Path, required=True) + args = parser.parse_args() + package, build = args.package.resolve(), args.build.resolve() + require(not build.exists(), "The build path must not exist.") + build.mkdir(parents=True) + compiler = shutil.which("clang++") or shutil.which("g++") + require(compiler, "A C++17 compiler is required.") + rows = [] + for engine in ["integer", "field"]: + source = package / "sources/four-register/independent/clean-zero" / (engine + ".cpp") + class_name = "Solver" if engine == "integer" else "Search" + state_name = "Rows" if engine == "integer" else "Basis" + off_name = "offrows" if engine == "integer" else "off" + terminal_name = "terminal" if engine == "integer" else "terminals" + setup = "" if engine == "integer" else "setup();" + code = f'''#define main saved_engine_main +#include {json.dumps(str(source))} +#undef main +int main() {{ + {setup} + for (int test = 0; test < 5; ++test) {{ + {class_name} solver; + int target = test == 1 ? 3 : 7; + solver.terms = {{{{target, 1 | 32 | 1024}}, {{0, 32768}}}}; + if (test == 2) {{ + solver.terms.push_back({{64, 2}}); + solver.terms.push_back({{128, 2}}); + solver.{off_name}.push_back(192); + }} + if (test == 3) {{ + solver.terms.push_back({{0, 2}}); + solver.terms.push_back({{64, 2}}); + solver.{off_name}.push_back(64); + }} + if (test == 4) {{ + solver.terms.push_back({{1, 2}}); + solver.terms.push_back({{2, 2}}); + solver.{off_name}.push_back(3); + }} + solver.go({state_name}{{}}); + std::cout << test << " " << solver.{terminal_name} << " " << solver.robust << "\\n"; + }} +}} +''' + harness = build / (engine + "-controls.cpp") + harness.write_text(code) + binary = build / (engine + "-controls") + compiled = subprocess.run([compiler, "-std=c++17", "-O2", + "-fsanitize=undefined", "-fno-sanitize-recover=all", + str(harness), "-o", str(binary)], + text=True, capture_output=True, check=True) + (build / (engine + "-compile.log")).write_text(compiled.stdout + compiled.stderr) + result = subprocess.run([str(binary)], text=True, capture_output=True, check=True) + (build / (engine + "-run.log")).write_text(result.stdout + result.stderr) + expected = "0 1 1\n1 1 0\n2 1 1\n3 0 0\n4 1 0\n" + require(result.stdout == expected, engine + " polynomial control results") + rows.append({"engine": engine, "output": result.stdout, + "source_sha256": hashlib.sha256(source.read_bytes()).hexdigest()}) + + optimized = subprocess.run([sys.executable, "-O", "-B", str(package / "verify.py"), + "--build", str(build / "optimized-output")], + text=True, capture_output=True) + require(optimized.returncode != 0 and "without -O" in optimized.stderr, + "Optimized Python must be rejected") + require(not (build / "optimized-output").exists(), "Optimized run wrote output") + environment = dict(os.environ, PYTHONOPTIMIZE="2") + isolated = subprocess.run([sys.executable, "-E", "-B", "-c", + "import sys; assert __debug__; print(sys.flags.optimize)"], + env=environment, text=True, capture_output=True, check=True) + require(isolated.stdout == "0\n", "Child optimization environment leaked") + copy = build / "tampered-package" + shutil.copytree(package, copy) + victim = copy / "sources/four-register/CLEAN-SPAN-FOUR.txt" + victim.write_bytes(victim.read_bytes() + b"\n") + tampered = subprocess.run([sys.executable, "-B", str(copy / "verify.py"), + "--build", str(build / "tampered-output")], + text=True, capture_output=True) + require(tampered.returncode != 0 and "Source hash:" in tampered.stderr, + "Source corruption must be rejected") + require(not (build / "tampered-output").exists(), "Tampered run wrote output") + result = {"status": "PASS_INDEPENDENT_CONTROLS", "polynomial_engines": rows, + "fixture_scope": "Five polynomial fixtures; these are not paid-call circuit constructions.", + "fixtures": ["accept monomial targets of support three", + "reject a target of support two", + "accept after a required collision", + "reject a collision that forces a zero paid frame", + "reject a target reduced to a two-frame span"], + "optimized_python_rejected": True, "source_corruption_rejected": True, + "child_optimization_environment_ignored": True} + (build / "receipt.json").write_text(json.dumps(result, indent=2) + "\n") + print(result["status"]) + + +if __name__ == "__main__": + main() diff --git a/research/bit-clean-extra-register/review/check_reductions.json b/research/bit-clean-extra-register/review/check_reductions.json new file mode 100644 index 0000000000..5e2ae0d27c --- /dev/null +++ b/research/bit-clean-extra-register/review/check_reductions.json @@ -0,0 +1,22 @@ +{ + "status": "PASS_INDEPENDENT_FINITE_REDUCTIONS", + "all_rank_one_idempotents": 120, + "zero_active_off_pattern_projectors": 24, + "distance_feasible_families": [ + { + "active_counts": [ + 2, + 2, + 2 + ], + "extra": [ + 7 + ] + } + ], + "active_rank_one_completion_patterns": { + "coordinate_plane": 6, + "coordinate_image_or_row": 6, + "unique": 16 + } +} diff --git a/research/bit-clean-extra-register/review/check_reductions.py b/research/bit-clean-extra-register/review/check_reductions.py new file mode 100644 index 0000000000..78929b327b --- /dev/null +++ b/research/bit-clean-extra-register/review/check_reductions.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +"""Check finite facts used by the written clean-register reductions.""" +from collections import Counter, defaultdict +from itertools import combinations_with_replacement, product +import json +from pathlib import Path + + +def outer(x, y, width): + return sum(y << (width * i) for i in range(width) if x >> i & 1) + + +def require(value, message): + if not value: + raise ValueError(message) + + +def main(): + off4 = sum(1 << (4 * i + j) for i in range(3) + for j in range(3) if i != j) + all_projectors = [(x, y) for x in range(1, 16) for y in range(1, 16) + if (x & y).bit_count() % 2] + zero = [(x, y) for x, y in all_projectors if not outer(x, y, 4) & off4] + declared = {(1 << i, 1 << i) for i in range(3)} + declared |= {(1 << i, 8 | (1 << i)) for i in range(3)} + declared |= {(8 | (1 << i), 1 << i) for i in range(3)} + declared |= {(8, 8 | v) for v in range(8)} + declared |= {(8 | v, 8) for v in range(8)} + require(len(all_projectors) == 120 and len(zero) == 24, + "Projector counts") + require(set(zero) == declared, "Projector alphabet") + + feasible = [] + for d in product(range(9), repeat=3): + total = sum(d) + if total > 8: + continue + for m in range((8 - total) // 2 + 1): + for extra in combinations_with_replacement(range(1, 8), m): + distance = [sum(d[i] for i in range(3) if w >> i & 1) + + sum((w & v).bit_count() % 2 for v in extra) + for w in range(1, 8)] + if min(distance) >= 3: + feasible.append({"active_counts": d, "extra": extra}) + require(feasible == [{"active_counts": (2, 2, 2), "extra": (7,)}], + "Distance multiplicity reduction") + + off3 = sum(1 << (3 * i + j) for i in range(3) + for j in range(3) if i != j) + patterns = defaultdict(list) + for x, y in product(range(1, 8), repeat=2): + pattern = outer(x, y, 3) & off3 + if pattern: + patterns[pattern].append((x, y)) + types = Counter() + for entries in patterns.values(): + if len(entries) == 1: + types["unique"] += 1 + elif any(all(not (x | y) & (1 << i) for x, y in entries) + for i in range(3)): + types["coordinate_plane"] += 1 + elif (len(entries) == 2 + and (any(all(x == 1 << i for x, y in entries) for i in range(3)) + or any(all(y == 1 << i for x, y in entries) for i in range(3)))): + types["coordinate_image_or_row"] += 1 + else: + raise ValueError("Unclassified rank-one completion pattern") + require(types == {"unique": 16, "coordinate_plane": 6, + "coordinate_image_or_row": 6}, "Completion counts") + result = {"status": "PASS_INDEPENDENT_FINITE_REDUCTIONS", + "all_rank_one_idempotents": len(all_projectors), + "zero_active_off_pattern_projectors": len(zero), + "distance_feasible_families": feasible, + "active_rank_one_completion_patterns": dict(types)} + Path(__file__).with_suffix(".json").write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps(result)) + + +if __name__ == "__main__": + main() diff --git a/research/bit-clean-extra-register/review/controls.log b/research/bit-clean-extra-register/review/controls.log new file mode 100644 index 0000000000..f1d11af1a2 --- /dev/null +++ b/research/bit-clean-extra-register/review/controls.log @@ -0,0 +1 @@ +PASS_INDEPENDENT_CONTROLS diff --git a/research/bit-clean-extra-register/review/controls/receipt.json b/research/bit-clean-extra-register/review/controls/receipt.json new file mode 100644 index 0000000000..7a484e5943 --- /dev/null +++ b/research/bit-clean-extra-register/review/controls/receipt.json @@ -0,0 +1,26 @@ +{ + "status": "PASS_INDEPENDENT_CONTROLS", + "polynomial_engines": [ + { + "engine": "integer", + "output": "0 1 1\n1 1 0\n2 1 1\n3 0 0\n4 1 0\n", + "source_sha256": "927fcb11154edfeabfdf852c0f243f82b7d5d56475ced11bdaa3417b8528b6d9" + }, + { + "engine": "field", + "output": "0 1 1\n1 1 0\n2 1 1\n3 0 0\n4 1 0\n", + "source_sha256": "a39b5f3ca6dbd506c6008e356a0239173e8dff53047c4a6e71972c6c35226c9e" + } + ], + "fixture_scope": "Five polynomial fixtures; these are not paid-call circuit constructions.", + "fixtures": [ + "accept monomial targets of support three", + "reject a target of support two", + "accept after a required collision", + "reject a collision that forces a zero paid frame", + "reject a target reduced to a two-frame span" + ], + "optimized_python_rejected": true, + "source_corruption_rejected": true, + "child_optimization_environment_ignored": true +} diff --git a/research/bit-clean-extra-register/review/eumemic-predecessor.txt b/research/bit-clean-extra-register/review/eumemic-predecessor.txt new file mode 100644 index 0000000000..dc04f533bd --- /dev/null +++ b/research/bit-clean-extra-register/review/eumemic-predecessor.txt @@ -0,0 +1,380 @@ +# Negative results from a search for a new coding mechanism (no new κ) + +Scoping note, **no new κ**: one README, six standard-library checkers and one data file. No existing file changes. + +**Question.** Every witness on the frontier, 7.43e-4 (#285) at the time of writing, gets its saving from one +mechanism: the label (index-coding) decoder of the paired-cube line. Each data role saves one rank unit through a +free entrance label, and a centre-plus-producer decoder pays for it. The per-level coding gain is G ≈ 1.003 at +m ≈ 110–120, so the saving exponent a ≈ ln G / ln m is under 10⁻³. We looked for a different mechanism that could +multiply that exponent by 2 or more, on both the bit and the complex side. + +**Answer.** We found none. This note records what we tried, what is proved, what was computed, and what is still +open, so that others need not repeat the same routes. Section 1 covers a search run on 9–10 October 2026. Section 2 +lists earlier routes from 8–9 October that we discarded at the time. + +**Relation to other lists.** This complements Swapnil Jain's +[closed-ideas list](https://github.com/Swapnil-jain/integer-mult-kappa/blob/main/docs/CLOSED_IDEAS.md) and its +papers P1 ([doi:10.5281/zenodo.23265442](https://doi.org/10.5281/zenodo.23265442)) and P2 +([doi:10.5281/zenodo.23266393](https://doi.org/10.5281/zenodo.23266393)). Where a row overlaps theirs, we say so. We use +their status labels: **[proof]** a complete argument; **[cert]** an exact computer certificate; **[exp]** a decisive +experiment or a floating-point computation named as such; **[arg]** a short argument, not written as a full proof. +Every closure holds only in its stated model. Nothing here is a lower bound for integer multiplication. + +```sh +cd research/negative-results-paradigm-search/checks +python3 -B complex_m2_lambda2_certificate.py # < 1 s, section 1.1(a) +python3 -B multiplicative_index_maps.py # < 1 s, section 1.3(d) +python3 -B fourier_duality_f3.py # < 1 s, section 1.3(c) +python3 -B nonlinear_frames_m1.py # about 2 s, section 1.3(f) +python3 -B flag_model_cliques.py 2 # < 1 s, section 1.4(c) +python3 -B flag_model_cliques.py 3 # about 10 s +python3 -B bh_sign_gauges.py # < 1 s, section 1.4(d) +``` + +## 0. Model and the constraint that shapes everything + +The two recursive tape primitives are the address-field interchange (bit side, payload F₂, frames are rational +shears Φ_M:(H,D)→(H+MD,D) over Z/q^b with q an odd prime) and the simultaneous H₀ layer (complex side, frames are +exact Gaussian-dyadic Clifford operators acting as g^{⊗f} on f columns). A frame network splits rows into W role +streams; pointwise gates act at a common frame; a frame change of rank t costs one child of width t·f. The saving a +is the root of the moment Σ_e (t_e/m)^{1−a} = W. For small a, a ≈ D/E, where D = Wm − Σ t_e is the deficit and +E = Σ t_e ln(m/t_e) is the entropy. + +For lower bounds we use the general register (dilation) model, which contains every frame network and allows gates +between registers at different frames: + + ∏_i ( I + ([g_i] − 1) N_i ) = [T] · (permutation) over K[G]^{W×W}, + +with N_i rank-one idempotents over the payload field K, g_i the paid frame changes and T the target. Cost-zero +factors absorb the free maps. Correctness for all column counts f is exactly this identity in the group ring. + +Two facts govern any new mechanism: +- **Both sides must move.** κ ≤ min(a_b, a_c) up to the assembly factor. In particular κ ≤ a_c/(1+a_c), because the + complex primitive's binary basis changes call chunk interchanges. A gain on one side alone is worth at most the + gap to the other side, under 2% today. +- **Small m pays enormously.** a = ln G / ln m. Any saving at m ≤ 6 would be worth at least 50 times today's + exponent. That is why much of the search below concentrates on small m. + +## 1. The search of 9–10 October 2026 + +### 1.1 Complex primitive + +**(a) m = 2: no saving for any frames. [cert]** +Model: frames are any matrices in GL₄(C) generated by Hadamards on the two qubits and free maps. Free maps are all +monomial matrices (any invertible diagonal, any permutation of the four basis states). Gate coefficients are any +complex numbers, and gates may join registers at different frames. +Certificate: the FO lemma with ρ(g) = conjugation by Λ²(g) on End(Λ²C⁴). +- Λ²C⁴ = P₁ ⊕ P₂ ⊕ P₃, where P_a = span{e_x ∧ e_{x⊕a}}, one plane per perfect matching of F₂². +- Y₀ = span{Π₁, Π₂, Π₃}, the coordinate projectors onto the P_a. Every monomial matrix permutes the three planes, so + Y₀ is invariant under the free group. +- f(g) = dim(Y₀ + ρ(g)Y₀) − dim Y₀ is 0 on every monomial matrix, 1 for the Hadamard on each matching, and 2 for + H⊗H. Hence s ≥ 2W = Wm. + +This strengthens the earlier Clifford-only result. It covers Clifford+T, arbitrary phases, the exact "y-phase" +frames below and non-unitary diagonal scalings. The script is `checks/complex_m2_lambda2_certificate.py`. + +**(b) m = 3: the natural certificates cannot exist; the case is open.** +- [proof] No torus-invariant FO certificate exists in characteristic ≠ 2. Suppose Y₀ lies in the weight-0 part of a + representation, is AGL(3,2)-invariant, and gives a rank-linear bound. Then the fixed spaces of the coset block + groups would give an n-multilinear representation of the Fano matroid. That is impossible when 2 is invertible, + and gate coefficients contain 1/2. +- [exp] The best FO bound we found in the enlarged model is s ≥ 2W, from difference-class projectors in Λ², giving + G ≤ 1.5. Searches over sums of irreducible pieces of Λ¹–Λ⁴ and Sym²–Sym³ found nothing better. +- In the Clifford model the earlier bound is s ≥ 50W/21. It leaves only W = 2 with s = 5 and W = 3 with s = 8 at + small W. + +**(b′) m = 3, W = 2: settled in the dilation normal form, open in the full register model.** +- [proof] *Window lemmas*, valid for any frame group because they use only subadditive cost, target cost 3 and + cost ≥ 1 per paid move. Write t_j for the scalar mixing between moves j and j+1. + - In a three-move window whose outside moves cost at most 2 in total, the identity coefficient forces + t_j[1][1]·t_{j+1}[1][1] = 0, and the inverse network forces t_j[0][0]·t_{j+1}[0][0] = 0. + - Two-move windows force antidiagonal mixing. + - No single move can cost s − 2 or more. +- [cert] *Dilation normal form* (scalar idempotents, with free elements only inside paid moves): no W = 2 saving + for any cost profile with s ≤ 5. + - Five rank-one moves leave 169 zero patterns and 84 coefficient systems. Gröbner bases over Q decided each one, + so the verdict holds over every field of characteristic 0. + - The 6 consistent systems all force g₁ = 1 or g₅ = 1. + - The other profiles with s = 4 or 5 leave no survivor. + - A second, numerical code path agrees on all 84 systems. + - Only the cost properties above are used, so this covers Clifford frames and Clifford plus 2^k-th-root phases. +- [cert] *Full register model*: W = 2 needs s ≥ 5. With one free B-element inserted anywhere (6 placements, about + 109,000 exact systems) there is still no saving; any W = 2 solution would need at least two such insertions + between scalar mixings. +- [exp] *FO search*: nothing beats the Clifford bound 50W/21. 5,127 new functions from flag, isotropic-line and + stabilizer-state modules gave at best 7/3. FO is also blind to the window constraints. +- Open: the full register model at W = 2, s = 5 with two or more inserted free elements, and W = 3, s = 8. + +**(c) Non-Clifford frames and approximate arithmetic. [proof]/[arg]** +- [arg] Rounded arithmetic is legitimate in the cost model. Non-dyadic constants cost O(log p) per entry, which the + leaf terms absorb. Error growth is polynomial in d, so O(log d) guard bits suffice, and dirty roles are restored to + the same absolute error. But the network identity must still hold exactly in C[G]: a fixed per-level defect does + not shrink to 2^{−p}. +- [proof] In the synthetic layout, records lie in C[y]/(y^r+1). A diagonal frame y^{θ(x)} is a controlled signed + cyclic shift of the record, so it is free and exact. These frames reduce to the Clifford case: + - with bounded exponents, setting y → 1 gives a Clifford network of equal cost; + - with exponents k + l·r/2^s, one gets Clifford plus 2^{s+1}-th roots of unity, valid for every Galois conjugate; + - phases algebraically independent of the rest specialise to 1. +- We found no mechanism by which non-Clifford frames enlarge the one-dimensional entrance label at large m. + +### 1.2 Bit primitive: the abelian register model with per-role Levi targets + +Each role may end at its own target C_w, any invertible lower-triangular matrix, because free scalings X_w on the H +fields and Z_w on the D fields at entry and exit turn the shear by C_w = X_w Z_w^{-1} into the shear by I. A common +target C is equivalent to I. Mixed targets break the common-target hypothesis behind the trace lemma (P1, §5) and +behind the parity cut. + +**(a) Flag theorem. [proof]** +Setting: ∏_a (I + ([A_a] − 1) N_a) = diag([C_w]) over F[L], with every C_w invertible lower triangular (uniform or +not), any rational frames A_a and any payload field F. Call a frame *up* if its strictly upper part is nonzero. +Then + + W m − s ≤ Σ_{a up} ( m/2 − rank A_a ). + +In particular, **m = 2 never saves, for any assignment of Levi targets.** +Proof. +1. The strictly-upper part φ is a homomorphism from L to an abelian group. It kills every target and every low + frame, so the up factors satisfy a target-zero identity in F[φ(L)]. +2. At a generic character the up factors are proper pseudo-reflections with product I. In compact-WY form, + X_up T Y_upᵀ = 0 with T invertible, and Sylvester's inequality gives rank X_up + rank Y_up ≤ #up. +3. The character ζ^{A_ii} kills no target, because invertible lower-triangular C_w have nonzero diagonal. The span + condition (below) then gives span{x_a : (A_a)_ii ≠ 0} = F^W, so W ≤ rank X_up + #{low a : (A_a)_ii ≠ 0}. +4. Sum over i, using rank A ≥ #(nonzero diagonal entries) for lower-triangular A: + mW ≤ m·rank X_up + Σ_low rank A_a. The same holds for Y. Add the two and use step 2 to get + mW ≤ (m/2)·#up + Σ_low rank A_a. Subtract s. + +With a common target, conjugate first; the bound then holds for every complete flag, with "up" meaning frames that +do not preserve it. Every inequality of the proof was checked on 18,200 exactly verified solutions from unpruned +solvers, and on 11,760 more from a pruned one. + +**(b) Character and span conditions with Levi targets. [proof]** +For a character χ with kernel K, let t and u count the frames and targets in K, and let d = E − W. Then: +- |t − u| ≤ d; +- span{x_a : A_a ∉ K} ⊇ span{e_w : C_w ∉ K}, and the same for the y_a. + +Targets that are all multiples of one matrix, for example a mix of I and 2I, look like a common target to every +characteristic-2 character. So "some roles at I, some at 2I" gives nothing at m = 2, and in general no more than a +common target does. + +**(c) Small exact searches at m = 3, W = 3. [cert]/[exp]** (not packaged here) +Rank-one integer frames u vᵀ with u, v ∈ {0, ±1}³, and every lower-triangular subset-sum target, under the flag, +parabolic, character and span filters: +- E = 4: no candidate. +- E = 5: impossible by the flag theorem. +- E = 6: no candidate among 4.5·10⁹ leaves. +- E = 7, sparse pool: every candidate dies on a mod-3 kernel. +- E = 7, full pool: incomplete. +- E = 8 with Levi targets: not run. + +**(d) Non-abelian frames with mid-network Levi maps (G₀ = shears ⋊ Levi pairs).** +Free Levi maps applied in the middle of a network act on each register's shear parts by n ↦ X n Z^{-1}. A single +paid shear can then act on different terms of one input with different effective shears. With X = 2I every shear +is a commutator, so all character-based bounds fail: doubled import, counting, span and flag. Simple FO certificates +from permutation modules reach a ratio of only 1.33, where 2 is needed. (e) settles the case anyway. + +**(e) Theorem G₀: the flag theorem survives mid-network Levi maps. [proof]** +Setting: G₀ = N ⋊ L. +- N = M_m(Q) are the shears; L are the pairs (X, Z) of invertible lower-triangular matrices, acting by + (X,Z)·M = X M Z^{-1}. +- The state lies in M_W(F[G₀]). Free operations are GL_W(F₂) mixing and left multiplication of any register by + any l ∈ L, at any time. Paid operations are shears, at cost rank M. +- Targets are Π·diag([c_u l_u]), with c_u invertible lower triangular and l_u arbitrary. + +Then W m − s ≤ Σ_{up} (m/2 − rank M_j), as in (a). So **m = 2 never saves in G₀ either.** + +Why the earlier tools failed: with X = 2I every shear is a commutator, so every one-dimensional character is +trivial on shears. The proof uses a matrix rank function instead of characters. +1. Absorb the free operations into the idempotent vectors, which now have entries in F[L]. Projecting G₀ → L + kills every paid factor, so the identity becomes ∏_j (I + a_j([n_{M_j}] − 1)b_jᵀ) = Π·diag([n_{c_u}])·Π^{-1}. +2. On the group rings of the solvable quotients G₀/N′, where N′ is spanned by the matrix units over a down-set + (L-invariant, hence normal), use the Sylvester rank function. Its sources: + - congruence subgroups are torsion-free; + - torsion-free elementary amenable group rings are Ore domains (Kropholler–Linnell–Moody, Tamari); + - rank([g] − 1) = 1 for g of infinite order; + - matrices over F[L] have the same rank in every such quotient. +3. Two quotient families give the two halves of the flag argument: + - dividing out the lower-triangular shears gives rk A_up + rk B_up ≤ #up; + - projecting onto the rectangles {r ≤ i ≤ c} gives W ≤ rk A_up + #{low j : (M_j)_ii ≠ 0}. + +The same proof allows free zero-in/garbage-out temporaries. A separate adversarial review found the proof correct. +Exact checks covered valid W = 2 networks that are genuinely non-abelian, including one where a single paid shear +acts on 7 terms of one input with 6 different effective shears. + +Scope: G₀ omits the free lower-left updates D += K·H of the full machine, under which N is not normal. The full +non-abelian Borel model at m = 2 is therefore not covered by this theorem. + +**(f) Abelian m = 3: s ≥ 2W + 1. [proof]** +- Tight-frame lemma: let k be a rank-one frame with A₀₂ ≠ 0, and let P be the set of frames whose strictly-upper + parts are parallel to k's. Then 2W ≤ #up − |P| + 2·#{low frames with A₁₁ ≠ 0}. The proof uses a functional on the + {0,1} × {1,2} block, which kills P and no target. +- At s = 2W, the flag theorem forces 2W up frames of rank one. The lemma then forces A₀₂ = 0 for every frame, and the + coordinate kernels A₀₀, A₂₂ and {A₀₁ = A₀₂ = 0} contradict each other. +- So W = 3 needs s ≥ 7, and W = 4 needs s ≥ 9. The gain bound is still G < 3/2. +- [cert]/[exp] A type-level enumeration (the coordinate-character conditions depend only on support patterns) and + {0,±1} box searches leave no candidate in the following cases; every candidate found was killed by the first-order + mod-2 condition: + - W = 3, E = 8, sparse box: 1,035,664 candidates; + - W = 4, E = 8, full box: 7,176 candidates; + - W = 3, E = 7, sparse box. +- Still open: W = 3 with s = 7 or 8, and W = 4 with s = 9 to 11. + +### 1.3 Machine operations outside the frame model + +Each operation below is linear-time on a multitape machine by the 02-streams lemmas. + +| | Operation | Verdict | Status | +|---|---|---|---| +| (a) | Address-dependent (masked) gates, with stream compression | Freezing every mask at one logical address gives an unmasked network of the same cost. A compressed stream of density ε needs at least ε(rank − log_Q(1/ε)) interchanges. So this reduces to (b) up to O(1/b). | [proof] | +| (b) | Clean ancillas (extra zero-initialised volume, garbage erased) | The first-order p-integral bound and the cut bounds survive; apply them to the data–data block. In the moment equation an ancilla of total rank R adds R to Σt_e and nothing to Wm, so it must raise the deficit by more than R. Nested dirty auxiliaries are deficit-neutral and dominate ancillas by more than 10× today. | [proof]/[arg] | +| (c) | Fourier duality (an odd-characteristic payload such as F₃ makes the WHT exact and growth-free) | An XOR-shear H ⊕= D equals WHT_H · diag((−1)^{ξ·D}) · WHT_H, and an interchange is 6 H-layers plus 3 free sign passes (checked exactly). It does not retire the bit primitive: the complex primitive's basis changes call chunk interchanges at width eK > e, so the recursion is circular, and a contiguous-slot layer network needs about 10 extra children per role against a deficit of about 0.2. Inside a network it is covered by the non-CSS-label row of P1. | [cert]/[arg] | +| (d) | Multiplicative index maps (multiplying an index by a fixed unit mod N is O(V)) | Transposition is k ↦ 2^e·k mod (2^{2e}−1). The CRT turns it into a free negation, but the CRT step is itself the expensive shear. *Valuation lemma:* any factorisation into fixed units of size at most C has length at least e/log₂C. BFS over the generators {−1, 2, 3, 5, 7} gives exactly e for e ≤ 10, the naive count. | [proof]/[cert] | +| (e) | Carry-free digitwise maps (XOR, F_q-linear maps, F_{q^k} arithmetic on whole fields) | Not linear-time by any known method. Free updates are cyclic shifts with carries plus fixed units, so cheap linear frames live in characteristic 0, where the trace lemma and the p-integral theorem apply. An escape from characteristic 0 must therefore be non-abelian, not cross-characteristic. | [arg] | +| (f) | Nonlinear controlled-shift frames (the offset may be any polynomial-time function of earlier fields) | The target still costs m per register: a backward-information function is subadditive, at most 1 per interchange and equal to m on the target. A nonlinear shear x += g(y) costs 2 children, not 1. Frames that are smooth at a common fixed point linearise through the Jacobian. At m = 1, Q = 3 the generated group is all of S₉, and the exact cost census matches these lemmas. Non-smooth frames evade every linear obstruction; permutation-module FO gives only s ≳ 2W. | [proof]/[cert]; open | +| (g) | Unequal or digit-class streams, multi-rate heads | Reduce to virtual registers, compression or copying, and to the P1 rows on unequal widths and mixed motifs. | [arg] | +| (h) | Sparse convolution and prefix-sum gates | Augmentation kills translations, so the derivative bound survives; the cut bounds survive. No mechanism found. | [arg] | + +**Follow-up on (f), nonlinear frames at small size.** +- [arg] **Common-frame networks with s ≤ 8 never save, for any frames (nonlinear included) and any gates.** + - A common-frame network is a one-shot code on the undirected graph of distinct gate frames, with at most s edges. + - Coding equals routing for at most 6 coding nodes, for trees, for graphs whose terminals lie on one face + (Okamura–Seymour), and for theta graphs (Liu–Que–Li–Li, arXiv:2608.06070, Theorems 5 and 7, and the earlier + work cited there). So a saving needs at least 7 frames and cyclomatic number at least 3. + - That settles m = 2 with W = 3 or 4, and m = 3 with W = 3, without search. The smallest open common-frame + case is m = 2, W = 5, s = 9. + - This assumes the cited coding model covers time-ordered gate circuits. +- [proof]/[cert] **At m = 2, nonlinear frames have no local advantage over linear flags.** In the machine's free + group (controlled shifts by any polynomial-time offset, plus fixed units), the largest set of pairwise + session-compatible unit-cost directions is exactly q, as for linear flags. It is 3 at q = 3 for every b, checked + exhaustively and by SAT. Carry-free fibre maps would give 9 at N = 9, but they are not linear-time. +- [cert] **Register-model searches.** Exact F₂[Γ] arithmetic at N = 3, W = 2, m = 2, s = 3, over two structured + classes (6.6·10⁶ and 7.95·10⁷ distinct states), found no saving. +- [exp] **FO bounds.** Permutation-module FO certificates, including an LP over all free-group-stable sets of + point pairs, give only s ≥ 4W/3. +- **Open:** the register model beyond these classes (W = 2 with s = 3, W = 3 with s = 4 or 5). It has no useful + first-order identity: the group is generated by involutions, so every characteristic-2 character is trivial. + +### 1.4 Other primitive families, and embedding known coding-gap codes + +The reduction used throughout is this. With free temporaries, a frame network is a frameless bijective circuit plus +a map of its gates into the frame space. The gain is therefore at most the coding gap of the frame space for sessions +at the target's relative position. The undirected unicast gap codes that refuted the Li–Li conjecture this month +(Braverman–He, arXiv:2610.10108; Zhang–Li–Li, arXiv:2610.09367) are the natural seeds. + +**(a) Frame families.** +- Permutation and signed-permutation frames, finite subgroups of GL(Z), and lattice-preserving finite linear groups + never save. FO on Λ/pΛ applies whenever the H and D parts split the lattice mod p. [proof] +- Qudit Clifford frames over Z/N give the same rank geometry for prime N, and are slot-additive across primes for + composite N (coordinate isolation). [arg] +- Abelian or cyclic frame groups (units mod N, digit rotations, Z/N translations) have l₁-embeddable metrics, so + their gap is 1. [arg] +- Tensor-power primitives A^{⊗e} are slot-additive without free carry-free mixing. [arg] +- Primitives defined through multiplication are circular. [arg] + +**(b) Cayley-graph seeds. [proof]** If a finite frame group with cost-1 generators S is used directly, with +sessions along an involutive target z at distance D, the gap is at most D/|S|. A gain needs physical degree below +the session distance, which is the opposite of the Tanner seeds: Braverman–He has degree 10 at distance 5. + +**(c) Full GL_{2m} flag model (non-abelian, same interchange primitive). [cert]** At m = 2, among the cost-1 +neighbours of a flag, the largest pairwise session-compatible set has size 2 at q = 2 and 3 at q = 3. In the abelian +shear model it is m = 2. So the local "compatible directions ≤ m" obstruction, which rules out isometric Tanner-code +embeddings in the abelian model, is model-specific. On the bit side, m = 2 is closed for the abelian and G₀ models +(1.2(a), (e)), but not yet for the full non-abelian flag model. Script: `checks/flag_model_cliques.py`. + +**(d) Braverman–He's PG(2,9) code with per-session sign gauges. [cert]** +- With a common target I, an isometric frame embedding at m = 5 with rank-one edges is impossible: on a geodesic, + steps are orthogonal idempotents, and 731 edges are crossed in opposite directions by different sessions. +- With targets C_i = ±C₀, geodesic steps are C_i·P. Opposite traversals become consistent exactly when the two + sessions have opposite signs, which turns the obstruction into a sign system on the 157 sessions × 735 edges. +- No session uses an edge in both directions, but the system is unbalanced: 23,025 violated constraints in one + component. Sign gauges do not help. +- With general Levi targets the embedding is heavily overdetermined: about 11,760 rank-one conditions against 4,550 + unknowns. + +Script: `checks/bh_sign_gauges.py`. The data file holds the deleted-edge list R and the vertex order π transcribed +from the paper's appendix. + +### 1.5 Literature, 15 September – 10 October 2026 + +We scanned arXiv (cs.DS, cs.IT, cs.CC, cs.DM, cs.SC, math.CO) through the 9 October listing, ECCC, openai/math +(unchanged since 8 October) and GitHub. We found no new mechanism. Items: +- Zhang–Li–Li and Braverman–He have no follow-ups. +- J. A. Sussman's Lean WHT/DFT package (jacobalansussman/wht-power-saving-lean). Its scratch-copy note prices + copy-free centres at ×1.71 and shows that copies along coordinate directions gain at most ×1.11–1.25. +- A Lean certificate that the Li–Li conjecture fails with an unbounded gap (chris1234555/ncc-certificate). It goes + from a fast algorithm to a coding gap, not the reverse. +- Adler (FOCS 1996) on XOR coding for transposition-like I/O problems. Its gain comes from broadcast with side + information, which bounded fan-out reduces to the label mechanism. +- Alman et al. on Kronecker powers: constant factors only, or table lookups that a fixed-alphabet machine cannot do. + Catalytic register programs bound space, not time. + +## 2. Earlier routes we tried and discarded (8–9 October 2026) + +These rows summarise exploration notes. Their scripts and certificates are not packaged here, so treat the +[cert] labels in this section as reports, and ask if you need a reproduction. + +### 2.1 In-class routes on the paired-cube design + +| Approach | How it failed | +|---|---| +| **5-pair ports** (bigger cubes, less centre loss) | Each 32-port cube needs 171 decoder channels, so the cost per port is about 4× the triples', against a 1.2–1.4× budget. Even at p = 16 the complex saving would be about 0.4× the triples'. (Compare P2's weight-five row.) | +| **Register recycling** (#184-style reuse of retired registers) | The peak number of simultaneously live registers forces at least 4.9 per port (4.76 under fresh-rank liveness), against about 3.45 needed for 2×. Even with the recycling conditions relaxed, the gain is +3.7% (at most about +5.4%). | +| **Source-assisted words** (#193, original sources cancel values) | Even with every source available everywhere (not actually allowed), κ gains only +2.9%. The extra registers come from fan-out, not from the cancellable part. | +| **Nested-chain decoder modules** | They would need sources that targets cannot read inside side roots, or about 220 extra centres. Those centres cost more than the whole deficit. | +| **Better pair modules** (exact minimum register count) | The J0 module is within about 7% of the best found, worth about +0.5–1% κ. No construction gap. | +| **Smaller cover / cancelling modules** | The cover dimension is fixed because a three-shear rotation is minimal. Cancelling sums would put unreadable sources into a root's frame, which the checker rejects. | +| **Centre restructuring** (built from P, reordered, split) | −1% to −7%, because the centre sums are already co-optimised with P. | +| **Root-role permutations, merging 2-port roots, gauge parameter** | Exactly neutral. | +| **Non-uniform local circuits, parity-based cube totals** | No gain, or −1.3%. | +| **Five-stage "bridged" schedule** (#209's idea) | Our pricing at the time: about +6% on the complex side but only +1.9% on the bit side, which then sets κ, so about +1.9% overall. #234 later realised it with a five-stage bit supplier as well. | + +### 2.2 New-primitive routes + +| Route | Result | Status | +|---|---|---| +| Different-frame (DF) gates: Clifford operator-valued gate coefficients | No saving at m ≤ 2 for any W (exact rational certificate over Sp(4,2)). Gates without a (1+i) denominator never save, at any m. At m = 3 the best bound is s ≥ 50W/21; the only surviving W = 2 profile is five rank-1 children. DF cannot cut centre loss: summing the per-class decoder identities gives K + H + B = I as scalars. | [cert]/[proof] | +| Characteristic-0 Tanner codes on the dual polar graph DSp(2m,2) (small-instance reduction: free temporaries give a one-shot code over Q(i) with sessions between opposite Lagrangians) | Every m = 2 LP optimiser found has no code over any field (tight-cut propagation, corridor argument). Sp(2m,2)-invariant schemes cannot deliver opposite-pair sessions. Product Tanner codes have causal gap exactly 1. | [proof]/[cert] | +| Small instances | No saving at m = 1, W ≤ 2, ≤ 5 session labels, ≤ 6 coding labels, cyclomatic number ≤ 2, product label families, mW ≤ 9, m = 2 with W ≤ 5, m = 3 with W ≤ 3. | [cert] | +| Centre decoders | The paired-cube and bit star decoders sit at their invariant minimum rank, and the dense readable remainder is forced at rank about h. Overcomplete or coordinate-direction centres gain at most about 4–10%. | [cert] | +| More than one saved dimension per data role | k-dimensional source labels need degree ≥ 3 exact-match indicators, so the centre rank grows from about h to about h⁴. Two-sided labels split the readers of a centre copy into about 15 classes at p = 12, multiplying copy cost. Port-mixing shears break the Pauli structure. | [arg] | +| Cover and stage structure | Within one pair's three-transfer swap with common-frame scatter, the cover penalty (ln 3 per local rank unit) is intrinsic; padding loses (4h −11%, 5h −18%). #209's five-stage twins evade this by sharing helpers across pairs. | [arg] | +| Cross-level and recursive primitives | A self-similar k-level scheme flattens to one level at (W^k, m^k). Gauged or network-valued children gain at most ×1.03. Cross-level labels give at most ×1.11 before auxiliaries. | [proof]/[arg] | +| Gain mechanisms in the Clifford model | Fixed points of the output permutation never save. Swap partners that share a label save nothing. A dirty-role relay at best breaks even. Each saving role needs ≥ 3 coded transfers; #209 later showed 2 suffice with free gates between pairs. Aux swaps (×0.73) and k-cycles (×0.27) lose. | [proof]/[arg] | +| Breaking min(a_b, a_c) | The bit network appears in the complex recursion only as rank-zero adapters, which the a_c moment already counts, so κ ≤ a_c/(1+a_c). | [arg] | +| Assembly weighting | The cover assemblies pass m* = min(a_b, (1−β)a_c) into an unchanged structured assembly. A balanced prefix (margin 1 − ε) gives about +0.05%. | [cert] | + +## 3. What remains open + +None of these has a construction. They are listed in rough order of how directly a positive answer would bear on κ; +remember that both sides must move. + +1. **Complex primitive, m = 3.** + - The full register model with W = 2 and s = 5 needs two or more free elements inserted between scalar mixings. + - W = 3 with s = 8 is open: the Clifford bound is s ≥ 50W/21, and the enlarged model has only s ≥ 2W. + - Torus-invariant FO certificates cannot exist there (Fano obstruction), so a proof needs a different tool. +2. **Bit primitive, abelian, m = 3.** W = 3 with s = 7 or 8, and W = 4 with s = 9 to 11. Proven bounds allow + G < 3/2. +3. **Bit primitive, full non-abelian model at m = 2.** Theorem G₀ does not cover the free lower-left updates + D += K·H. With them the shears no longer form a normal subgroup. +4. **Non-smooth nonlinear frames, in the register (superposition) model.** W = 2 with s = 3, and W = 3 with s = 4 or + 5, beyond the searched classes. The first open common-frame case is m = 2, W = 5, s = 9. +5. **Large m.** No mechanism is known that saves more than one rank unit per data role at a decoder cost comparable + to today's. The flag theorem and the FO bounds still allow gains up to about m/2. So the obstruction is the lack + of a construction, not a proof. + +## 4. Credits and disclosure + +The obstruction tools we cite: +- The FO lemma, the p-integral (mixed-characteristic) theorem, the trace identity, the support lemma and character + counting come from our earlier exploration. P1 and P2 independently prove the overlapping statements; cite those. +- The doubled-import bound E + σ ≥ 2W is ours. It agrees with P1's "at least 2W children" row. + +Other credits: +- Paired cubes: icekylinx (#144). Source-assisted compression: icekylinx (#184). Pair donors: ikeboy (#193). +- Paired-cube design ceiling: DaysSky (#201). Structural barriers: huxint (#203). Lucas-parity obstruction: + GamingPuzzled (#231). +- Five-stage bridged schedule: J. A. Sussman (#209). Five-stage suppliers: hcg890 (#234). +- Closed-ideas list and papers P1/P2: Swapnil Jain. +- The PG(2,9) instance and gap: Braverman and He. Amplification framework: Zhang, Li and Li. + +Prepared by eumemic with substantial Anthropic Claude assistance (Claude Code agents ran the searches, proofs and +checks). Apache-2.0. diff --git a/research/bit-clean-extra-register/review/full-replay-runner.py b/research/bit-clean-extra-register/review/full-replay-runner.py new file mode 100644 index 0000000000..7c1833123d --- /dev/null +++ b/research/bit-clean-extra-register/review/full-replay-runner.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +"""Replay the saved clean-register checks in a new directory.""" +import argparse +from collections import Counter +import hashlib +import importlib.util +import itertools +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys + +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + return json.loads(path.read_text()) + + +def run(command, log): + print("Run:", " ".join(map(str, command)), flush=True) + with log.open("w") as output: + subprocess.run(list(map(str, command)), check=True, + stdout=output, stderr=subprocess.STDOUT) + + +def check_alphabets(path): + # This uses the dual-vector construction from the independent audit. + bases = [] + for columns in itertools.combinations(range(1, 16), 4): + dual = [] + for i in range(4): + choices = [v for v in range(1, 16) + if all((v & c).bit_count() % 2 == int(i == j) + for j, c in enumerate(columns))] + if len(choices) != 1: + break + dual.append(choices[0]) + if len(dual) == 4: + bases.append(tuple(sorted(zip(columns, dual)))) + def permute(v, p): + return sum(((v >> i) & 1) << p[i] for i in range(4)) + def canonical(basis): + return min(tuple(sorted((permute(x, p + (3,)), + permute(y, p + (3,))) for x, y in basis)) + for p in itertools.permutations(range(3))) + orbits = Counter(canonical(basis) for basis in bases) + rows = [list(map(int, line.split())) for line in path.read_text().splitlines()] + require(all(len(row) == 16 for row in rows), "Invalid alphabet row") + alphabets = [tuple(zip(row[::2], row[1::2])) for row in rows] + identity = tuple((1 << i, 1 << i) for i in range(4)) + require(len(bases) == 840 and len(orbits) == 166, "Basis count") + require(all(row[:4] == identity for row in alphabets), "Coordinate basis") + require(len(alphabets) == 166 and + set(row[4:] for row in alphabets) == set(orbits), "Basis coverage") + require(Counter(orbits.values()) == {1: 6, 3: 42, 6: 118}, "Orbit sizes") + return {"unordered_bases": 840, "alphabets": 166, + "orbit_sizes": dict(Counter(orbits.values()))} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--build", type=Path, required=True) + args = parser.parse_args() + build = args.build.resolve() + require(not build.exists(), "The build directory exists.") + manifest = read(ROOT / "SOURCE-MANIFEST.json") + for item in manifest["files"]: + require(hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() + == item["sha256"], "Source hash: " + item["package"]) + build.mkdir(parents=True) + shutil.copytree(ROOT / "sources", build / "sources") + clean = build / "sources/four-register/independent/clean-zero" + audit = build / "sources/four-register/independent-audit" + basis = build / "sources/doubling-architecture/clean-ancilla" + selected = build / "sources/doubling-architecture/rank-independent/clean-audit" + compiler = os.environ.get("CXX") or shutil.which("clang++") or shutil.which("g++") + require(compiler is not None, "A C++17 compiler is required.") + for source, target in [(clean / "integer.cpp", clean / "integer"), + (clean / "field.cpp", clean / "field"), + (audit / "check_clean_zero_orders.cpp", audit / "orders"), + (basis / "two_bases.cpp", basis / "two_bases"), + (selected / "selected_words.cpp", selected / "selected_words")]: + run([compiler, "-O3", "-std=c++17", source, "-o", target], + build / (target.name + "-compile.log")) + run([sys.executable, clean / "generate.py"], build / "clean-generate.log") + expected = read(ROOT / "expected/clean-zero-result.json") + require(hashlib.sha256((clean / "words.bin").read_bytes()).hexdigest() + == expected["word_sha256"], "Clean word stream") + run([audit / "orders", audit / "clean-zero-family-metadata.txt", clean / "words.bin"], + build / "independent-orders.json") + independent = read(build / "independent-orders.json") + require(independent == expected["independent_front_end_audit"], "Independent orders") + for engine in ["integer", "field"]: + run([clean / engine, clean / "words.bin", clean / (engine + ".jsonl")], + build / (engine + "-run.log")) + for suffix in [".jsonl", ".jsonl.terminals.jsonl"]: + require((clean / ("integer" + suffix)).read_bytes() == + (clean / ("field" + suffix)).read_bytes(), "Engine comparison: " + suffix) + totals = json.loads((clean / "integer.jsonl").read_text().splitlines()[-1]) + require(totals == expected["engine_totals"], "Clean totals") + require(len((clean / "integer.jsonl.terminals.jsonl").read_text().splitlines()) + == expected["terminal_word_count"], "Terminal word count") + catalogue = check_alphabets(basis / "ALPHABETS.txt") + results = [] + for index in range(166): + output = build / f"basis-{index:03d}.json" + run([basis / "two_bases", basis / "ALPHABETS.txt", index, output], + build / f"basis-{index:03d}.log") + results.append(read(output)) + full = {"alphabets": 166, "completed": len(results), "results": results, + "states": [sum(row["states"][i] for row in results) for i in range(4)]} + for key in ["searched_words", "terminals", "robust"]: + full[key] = sum(row[key] for row in results) + (build / "all-basis-summary.json").write_text(json.dumps(full, indent=2) + "\n") + old = read(ROOT / "expected/all-basis-summary.json") + require(full["completed"] == full["alphabets"] == 166, "Incomplete basis run") + for key in ["searched_words", "states", "terminals", "robust"]: + require(full[key] == old[key], "Basis total: " + key) + for actual, expected_row in zip(full["results"], old["results"]): + require(actual["complete"] and actual["robust"] == 0, "Incomplete alphabet") + for key in expected_row: + if key != "seconds": + require(actual[key] == expected_row[key], "Alphabet field: " + key) + fixed = read(ROOT / "expected/selected-comparison.json")["results"] + words = [row["word"] for row in fixed] + encoded = "".join(" ".join(str(n) for xy in word for n in xy) + "\n" for word in words) + output = subprocess.run([str(selected / "selected_words")], input=encoded, + text=True, capture_output=True, check=True) + field = [json.loads(line) for line in output.stdout.splitlines()] + require(len(field) == len(words) == 48, "Selected word count") + spec = importlib.util.spec_from_file_location("clean_search", basis / "search.py") + exact = importlib.util.module_from_spec(spec) + spec.loader.exec_module(exact) + checks = [] + for i, word in enumerate(words): + rational = exact.solve(word) + require(len(rational["found"]) == field[i]["robust"] == 0, "Selected survivor") + require(rational["stats"]["terminals"] == field[i]["terminals"], "Selected terminals") + checks.append({"case": i, "word": word, "rational": rational["stats"], "field": field[i]}) + exact.d.rref.cache_clear() + exact.d.rep.cache_clear() + exact.d.add.cache_clear() + (build / "selected-comparison.json").write_text(json.dumps(checks, indent=2) + "\n") + receipt = {"status": "PASS_CLEAN_RESTRICTED_CLASSES", "clean_zero": totals, + "independent_orders": independent, "basis_catalogue": catalogue, + "all_basis": {key: full[key] for key in + ["alphabets", "completed", "searched_words", "states", "terminals", "robust"]}, + "selected_rational_field_words": len(checks), + "source_manifest_sha256": hashlib.sha256((ROOT / "SOURCE-MANIFEST.json").read_bytes()).hexdigest(), + "scope": "Restricted clean endpoint; frame spans five and six remain open."} + (build / "receipt.json").write_text(json.dumps(receipt, indent=2) + "\n") + print(receipt["status"], totals["words"], full["searched_words"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/bit-clean-extra-register/review/huxint-predecessor.txt b/research/bit-clean-extra-register/review/huxint-predecessor.txt new file mode 100644 index 0000000000..043bc4af5e --- /dev/null +++ b/research/bit-clean-extra-register/review/huxint-predecessor.txt @@ -0,0 +1,355 @@ +# Cost barriers for a saving of 1/100 + +This note gives necessary conditions for specified finite interfaces. It does +not prove a new multiplication bound. In particular, it does not rule out +`kappa = 0.01` for a different architecture. + +## 1. A paid-moment inequality + +Let an ordinary finite supplier have ambient width `m`, stock `W`, and `n_r` +children of width `0 < r < m`. Put + +``` +D = m W - sum_r n_r r, +C = sum_r n_r r log(m/r). +``` + +Acceptance at a positive saving `a` requires + +``` +sum_r n_r r (m/r)^a < m W. +``` + +Since `exp(x) >= 1+x`, necessarily `a C < D`. For any retained submultiset +of children, `C_keep <= C`, so `a < D/C_keep`. Dropping all other entropy +costs is a favorable relaxation, not an implementation. Positive wrappers, +fallbacks and scalar tolls cannot improve this upper bound when they leave +this moment and its deficit budget intact. + +The elementary entropy bound was also used in DaysSky's PR #192. The use +here is different: discard the entire auxiliary circuit and bound the data +interface itself. The balanced assembly has `kappa < a/(1+a) < a` for its +limiting ordinary supplier (cf. PR #183). We use the weaker `kappa < a` for +the displayed ceilings. No historical factor-of-five assembly is used. + +## 2. The current data itineraries already exclude 0.01 + +The pinned complex profile is PR #193, whose full commit is recorded +in `inputs/complex-pr193.json`. The bit profile is PR #187, pinned separately +in `inputs/bit-pr187.json`. The input files contain the complete child +histograms and the exact source/target subhistograms, with source-file hashes. +The checker recounts stock, rank, deficit and submultiset inclusion. + +In the three-block shared-core interface, `m=3h` and `D=2v-3 ell`. +The data submultiset consists of three copies of the source and target +itineraries and `2v` rank-two complement children. It is: + +| Profile | h | v | ell | Data children, width: multiplicity | +| --- | ---: | ---: | ---: | --- | +| Complex #193 | 22 | 1320 | 440 | 1:15840, 2:6600, 18:7920 | +| Bit #187 | 24 | 1760 | 528 | 1:18480, 2:6160, 20:5280, 21:2640, 22:2640 | + +These give the following strict upper bounds on `a`, with every auxiliary +entropy cost removed: + +| Profile | Retain the copied-center loss | Grant zero center loss, D <= 2v | +| --- | ---: | ---: | +| Complex #193 | 0.004433342 | 0.008866683 | +| Bit #187 | 0.004893592 | 0.008897440 | + +At `a=0.01` the data alone require deficit greater than `2.28165 v` and +`2.27179 v`, respectively. Both exceed even the favorable `2v` budget. +The required deficit is computed directly from the exponential uplift, not +by treating the first-order approximation as an equality. + +Thus eliminating auxiliary calls or copied-center loss while keeping these +data calls and `D<=2v` cannot reach 0.01. This does not cover a change in +data interfaces, cross-stage fusion, a different deficit identity, or a new +recurrence. A finite-leaf or multitype scheme must be assessed against its +actual recurrence; it cannot be inserted into this theorem by name alone. + +## 3. An odd-dimensional paired-cube extension + +This is a proposed algebraic family and an optimistic cost screen. We do +not supply its complete framed side circuit, bit companion, prime compiler +or all-size assembly. + +Let `d=2t+1 >= 3` and `p>=d+1`. Partition `h=2p` coordinates into pairs. +Each port chooses one coordinate from each of `d` distinct pairs. There are +`v=2^d binom(p,d)` ports. Define the scalar fitting matrix + +``` +B[T,S] = b_d(|T intersection S|), +b_d(z) = product_(j=1..t) (z-(2j-1))/(d-(2j-1)). +``` + +Its diagonal is one, and every off-diagonal odd intersection is a root. +Let `B_block` keep only pairs in the same selector cube, and put +`K=I-B_block`, `H=B_block-B`. Then `K+H+B=I`, and both side terms are +supported on binary-orthogonal source/target pairs. + +### The local K is an involution in every odd dimension + +On a selector cube `F2^d`, let `P` project onto Walsh characters of degree +at most `t`. Exactly half of all characters have that degree, so the +diagonal of `2P` is one. Complementing a character multiplies its value at +a difference `x` by `(-1)^|x|`. At every nonzero even-weight `x`, the sum of +all characters is zero and is twice the low-degree sum. Thus the kernel of +`2P` vanishes there. + +Its radial kernel is a polynomial of degree at most `t` in intersection +size. The `t` prescribed roots and its diagonal value identify it uniquely +as `b_d`. Consequently `B_block=2P` and `(I-B_block)^2=I`. Its nonzero +off-diagonal entries join opposite selector parities. Its entries are +dyadic by the Walsh formula, irrespective of how the product polynomial is +written. + +Each parity class of addresses spans a binary `d`-space: the pair-difference +vectors with even selector parity have dimension `d-1`, and adding one +odd-norm port adds one dimension. The opposite class is orthogonal to it. +The original-source mixing argument therefore has candidate source chain +`[d-1,h-d-1,1]`. A retained lexicographic target flag has chain +`[h-d-1,1,...,1]` with `d` ones. These are compatible endpoint ingredients, +not a complete global word. + +### Copied t-star center budget + +The polynomial `b_d(z)` has degree `t`. Write +`b_d(z)=sum_j b_j binom(z,j)`. For a transversal coordinate t-subset `U`, +use the star `Z_U=sum_(S containing U) x_S`. The identity + +``` +sum_(U subset S, |U|=t) binom(|U intersection T|,j) + = binom(|S intersection T|,j) binom(d-j,t-j) +``` + +expresses the whole center matrix through these stars, using scatter +coefficient `sum_j b_j binom(|U intersection T|,j)/binom(d-j,t-j)`. +There are `2^t binom(p,t)` such stars. + +The span of the ports in a fixed star has dimension `h-2t`. The fixed +partner coordinates vanish; the fixed selected coordinates have one common +coefficient. Differences of outside ports generate the even-parity space +on the other `2(p-t)` coordinates: flips generate each pair difference, and +exchanging selected pairs generates all even pair occupancies. The strict +inequality `p>d` ensures those exchanges exist. One star port supplies the +remaining dimension. Thus the copied-star interface has + +``` +ell = 2^t binom(p,t) (h-2t), +D <= 2v-3 ell, m=3h=6p. +``` + +The inequality is a hypothesis inherited from this copied-center shared +compiler, allowing additional nonmonotone losses. A construction that +changes this center budget is outside the screen. + +### A ceiling even with redesigned local data chains + +Put `f(r)=r log(3h/r)`, with `f(0)=0`. It is increasing on `[0,h]`. +A data chain whose endpoints have distance `h-1` has total jump rank at +least `h-1`. If one jump is at least `h-1`, its entropy is already at least +`f(h-1)`. Otherwise concavity gives +`f(r) >= r f(h-1)/(h-1)` for every jump, and summing proves the same bound. +This permits nonmonotone chains, provided every local jump is at most `h`. + +Six source/target chains per port and the two complement children therefore +give the circuit-independent floor + +``` +C_data/v >= 6(h-1) log(3h/(h-1)) + 4 log(3h/2). +``` + +Together with `D<=2v-3 ell`, every supplier in this stated family satisfies + +``` +a < 0.008094. +``` + +The largest relaxed bound in the finite part occurs at `(p,d)=(13,5)` and +is less than `0.008093706`. Keeping the specific destructive-source and +lexicographic target chains instead gives `a<0.005164`, with the largest +relaxation at `(p,d)=(14,5)`. + +This is an infinite-family screen, not just a finite parameter scan. For +`p>=30`, `D/v<=2`, and the data lower bound is strictly greater than +`(12p-2) log 3`. The resulting ceiling +`2/((12p-2) log 3)` decreases with p and is already below both finite maxima +at p=30. The checker exhausts all odd `3<=d=5`, `h=2p`. Let `A` be +the port-by-coordinate incidence matrix. A nonzero row in its coordinate +star span has values + +``` +f(S) = sum_(i in S) c_i. +``` + +For every such characteristic-zero coefficient vector, the binary span of +the ports where `f(S)` is nonzero has dimension at least `h-2`. + +First suppose the coefficients differ within one coordinate pair i. For +each outside two-coordinate edge from distinct pairs, at least one of its +two extensions by pair i has nonzero f: their values differ by a fixed +nonzero coefficient difference. The projections of these supported ports +onto the outside coordinates therefore contain all edges of the connected +complete multipartite graph on the other p-1 coordinate pairs. Its binary +edge span has dimension `h-3`. Lift the three edges of an outside triangle +using supported ports. Their outside coordinates sum to zero, while their +pair-i coordinates have odd total parity and do not vanish. The projection +kernel has dimension at least one, proving the `h-2` bound. + +Otherwise both coefficients in pair i have one value a_i. A coarse triple +is active when its three a-values sum to a nonzero value; then all its eight +selectors belong to the support. If one pair i is never active, equations +`a_i+a_j+a_k=0` for all other j,k force all outside a_j to be one value b +and `a_i=-2b`. Nonzero f implies b is nonzero. The support is exactly every +triple avoiding pair i. Since p-1>=4, these ports span all `h-2` outside +coordinates over F2. + +If every pair is active, the support contains all p pair-difference +directions. If all a_i agree, the whole port family is supported. Otherwise +choose a_i different from a_j. For each pair k,l outside i,j, at least one +of the coarse triples `{i,k,l}`, `{j,k,l}` is active. Projecting their +coarse incidence vectors outside i,j gives all edges on p-2 vertices, +whose span has dimension p-3. A triangle of such edges lifts to a nonzero +kernel vector on i,j, giving coarse span at least p-2. Quotienting the +full coordinate support by the p pair-difference directions thus proves +dimension at least `p+(p-2)=h-2`. + +Now A has rational rank h. Indeed, a coefficient relation zero on every +port first forces equality within every pair by selector flips, and then +forces all pair coefficients equal by comparing triples; three times that +common coefficient is zero. Also + +``` +B = (AA^T-J)/2 = A (I-J_h/9) A^T / 2. +``` + +The middle matrix is invertible because the even integer h is not 9. +Hence B has rank h and its row space is exactly the coordinate-star span. +In any factorization `B=UV` through exactly h scalar centers, V has h +independent nonzero rows in that same span. The support lemma charges +at least `h-2` copied-center dimensions per row: + +``` +ell >= h(h-2). +``` + +The coordinate stars attain equality. Thus merely rotating, mixing or +rescaling a rank-minimal center basis cannot reduce the selected triple +construction's center loss. For the selected p=11 this lower bound is 440. + +The qualifier **rank-minimal** matters. An overcomplete factor may use +rows outside the star row space whose contributions cancel after scatter; +this proof does not bound such a factor. Sharing the center computation +across stages or replacing copied centers also changes the hypotheses. +At p=4 the support lemma itself fails: a linear form supported on the one +cube avoiding a specified pair has binary support rank 4, below h-2=6. +That is an explicit domain control, not omitted from the checker. + +## 5. A common triangular frame flag precludes any bit rank deficit + +Consider the general finite bit contract: every role has an arbitrary +independent input, the completed scalar circuit is a permutation `rho`, all +incidences of a gate share one rational matrix, and + +``` +M_out(rho(w)) - M_in(w) = I_m. +``` + +If all source, gate and sink matrices are simultaneously upper triangular +over one characteristic-zero extension field, then **s >= Wm**. The matrices +need not commute, be projections, or be diagonalizable. + +To prove this, conjugate them by the common basis; rational matrix ranks do +not change on extending the field. For one diagonal coordinate j, partition +all vertices by their j-th diagonal entry `lambda`. Regard all gates with +the same entry as a single processor and allow it free internal computation. +Its known inputs are exactly the source roles labeled lambda. Every output +at this processor demands an independent original input labeled lambda-1, +by the endpoint equation, so none of those requested inputs is initially +known there. + +Each incoming edge from a different label carries one scalar. The rank of +the requested outside-input transfer, or equivalently its entropy for +uniform independent bits, forces at least one such incoming edge per output +at that processor. Summing over processors gives at least W edges whose +j-th diagonal entries change. This argument permits arbitrary communication +between gates with the same label, so that relaxation can only strengthen +the exclusion. + +An upper triangular matrix has rank at least its number of nonzero diagonal +entries: take the principal minor on those entries. Therefore + +``` +s = sum_edges rank(M_head-M_tail) + >= sum_j number_of_edges_with_changed_diagonal_j + >= Wm. +``` + +In particular, pairwise commuting frames are excluded: a finite commuting +family over an algebraically closed characteristic-zero field is +simultaneously triangularizable, by a common eigenvector and induction on +the quotient. A rational common eigenbasis is not required. + +`triangular_obstruction.py` checks a supplied exact rational common basis, +or pairwise commutation. Failing either sufficient check does not establish +a deficit. This theorem concerns the rational-matrix **bit shear** contract; +it is not a theorem about all binary Lagrangian/Clifford frame families. + +## 6. Locally reused Fano networks + +The graph and balanced 10-role, 14-vertex model come from the retained +`scripts/experiments/fano_completion.py` and `balanced_fano.py`, with their +original attribution. Earlier work excluded the unmodified balanced model +with the three Fano demands fixed. Here an auxiliary output stub may be +connected to a later auxiliary input stub. Each stub is used at most once. +Chronology prevents cycles; no additional decoding circuit is appended. + +There are exactly 87 such choices, including the unchanged graph. Inputs +and outputs after each splice are checked to remain partitions of the +physical roles. Every remaining input is independent. Sixteen choices +preserve the original three-demand routing obstruction. On each of these, +the independent standard-library meet-in-the-middle replay excludes all +`6^14` choices of local `GL(2,F2)` matrices, with the other outputs free. + +The broader C++ check drops even those three terminal obligations. For every +one of the 87 topologies it enumerates **all** completed scalar permutations +and all port-routing permutations. The sets are equal. Hence none of these +scalar completions admits a rational rank deficit in any dimension, by the +retained routing theorem. Keeping only one prefix per key would be +insufficient for this claim; the implementation retains every prefix and +checks every matching suffix/prefix pair. + +Each half has `6^7=279936` assignments. A complete product is a permutation +exactly when the columns of the prefix and inverse suffix agree as +multisets. Both local direction choices and all auxiliary permutations are +included. Routing independently enumerates straight/cross choices at the +14 vertices. Small controls compare this algorithm with direct enumeration +of every complete local word. + +Vector blocks are separate solver experiments. A `sat` result would need an +independent all-column replay, routing analysis and rational-frame witness. +An `unsat` solver report is not upgraded here to a separately checked +impossibility proof; `unknown` and timeout remain unresolved. No vector +experiment is used in the exact ceilings above. + +## Arithmetic and limits + +Logarithms use binary range reduction and +`log x=2 sum_(j>=0) z^(2j+1)/(2j+1)`, `z=(x-1)/(x+1)`, with an explicit +geometric tail. Lower bounds are rounded down on a `10^-24` rational grid. +The exponential uplift uses a finite sum of positive Taylor terms. All +upper ceilings divide by a lower entropy bound, so rounding is favorable +to the hypothetical candidate. No floating-point value is an acceptance +criterion. + +Finite arithmetic and bounded exhaustive search do not formalize the whole +multiplication theorem. The inherited analytic, all-size, weighted compiler, +row restoration, precision and fixed-tape contracts remain separate. The +results above identify assumptions a successful new architecture must change; +they do not assert that any suggested replacement will succeed. diff --git a/research/bit-clean-extra-register/review/replay.log b/research/bit-clean-extra-register/review/replay.log new file mode 100644 index 0000000000..c7bd2e15a5 --- /dev/null +++ b/research/bit-clean-extra-register/review/replay.log @@ -0,0 +1,176 @@ +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/integer.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/integer +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/field.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/field +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent-audit/check_clean_zero_orders.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent-audit/orders +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/rank-independent/clean-audit/selected_words.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/rank-independent/clean-audit/selected_words +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/generate.py +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent-audit/orders /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent-audit/clean-zero-family-metadata.txt /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/words.bin +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/integer /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/words.bin /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/integer.jsonl +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/field /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/words.bin /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/four-register/independent/clean-zero/field.jsonl +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 0 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-000.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 1 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-001.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 2 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-002.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 3 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-003.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 4 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-004.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 5 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-005.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 6 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-006.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 7 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-007.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 8 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-008.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 9 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-009.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 10 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-010.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 11 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-011.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 12 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-012.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 13 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-013.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 14 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-014.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 15 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-015.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 16 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-016.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-017.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 18 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-018.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 19 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-019.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 20 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-020.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 21 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-021.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 22 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-022.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 23 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-023.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 24 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-024.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 25 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-025.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 26 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-026.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 27 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-027.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 28 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-028.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 29 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-029.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 30 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-030.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 31 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-031.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 32 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-032.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 33 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-033.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 34 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-034.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 35 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-035.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 36 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-036.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 37 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-037.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 38 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-038.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 39 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-039.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 40 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-040.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 41 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-041.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 42 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-042.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 43 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-043.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 44 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-044.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 45 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-045.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 46 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-046.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 47 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-047.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 48 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-048.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 49 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-049.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 50 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-050.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 51 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-051.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 52 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-052.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 53 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-053.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 54 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-054.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 55 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-055.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 56 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-056.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 57 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-057.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 58 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-058.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 59 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-059.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 60 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-060.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 61 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-061.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 62 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-062.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 63 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-063.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 64 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-064.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 65 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-065.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 66 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-066.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 67 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-067.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 68 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-068.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 69 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-069.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 70 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-070.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 71 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-071.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 72 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-072.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 73 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-073.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 74 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-074.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 75 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-075.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 76 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-076.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 77 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-077.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 78 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-078.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 79 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-079.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 80 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-080.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 81 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-081.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 82 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-082.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 83 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-083.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 84 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-084.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 85 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-085.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 86 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-086.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 87 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-087.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 88 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-088.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 89 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-089.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 90 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-090.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 91 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-091.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 92 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-092.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 93 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-093.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 94 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-094.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 95 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-095.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 96 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-096.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 97 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-097.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 98 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-098.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 99 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-099.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 100 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-100.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 101 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-101.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 102 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-102.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 103 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-103.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 104 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-104.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 105 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-105.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 106 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-106.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 107 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-107.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 108 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-108.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 109 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-109.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 110 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-110.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 111 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-111.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 112 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-112.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 113 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-113.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 114 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-114.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 115 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-115.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 116 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-116.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 117 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-117.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 118 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-118.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 119 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-119.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 120 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-120.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 121 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-121.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 122 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-122.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 123 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-123.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 124 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-124.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 125 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-125.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 126 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-126.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 127 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-127.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 128 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-128.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 129 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-129.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 130 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-130.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 131 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-131.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 132 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-132.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 133 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-133.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 134 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-134.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 135 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-135.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 136 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-136.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 137 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-137.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 138 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-138.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 139 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-139.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 140 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-140.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 141 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-141.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 142 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-142.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 143 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-143.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 144 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-144.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 145 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-145.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 146 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-146.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 147 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-147.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 148 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-148.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 149 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-149.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 150 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-150.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 151 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-151.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 152 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-152.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 153 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-153.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 154 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-154.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 155 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-155.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 156 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-156.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 157 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-157.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 158 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-158.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 159 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-159.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 160 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-160.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 161 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-161.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 162 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-162.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 163 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-163.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 164 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-164.json +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/two_bases /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt 165 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/reviews/clean-register/replay/basis-165.json +PASS_CLEAN_RESTRICTED_CLASSES 314666 7406643 diff --git a/research/bit-clean-extra-register/review/replay/receipt.json b/research/bit-clean-extra-register/review/replay/receipt.json new file mode 100644 index 0000000000..71c580ce5b --- /dev/null +++ b/research/bit-clean-extra-register/review/replay/receipt.json @@ -0,0 +1,49 @@ +{ + "status": "PASS_CLEAN_RESTRICTED_CLASSES", + "clean_zero": { + "words": 314666, + "states": [ + 314666, + 1005125, + 1024411, + 2160151 + ], + "terminals": 20430, + "robust": 0, + "parity_prunes": 0, + "zero_frame_prunes": 1612361 + }, + "independent_orders": { + "status": "PASS_INDEPENDENT_CLEAN_ZERO_ORDER_COVERAGE", + "families": 216, + "raw_orders": 3674160, + "commutation_orders": 314666, + "binary_word_stream_identical": true, + "reversal_used": false + }, + "basis_catalogue": { + "unordered_bases": 840, + "alphabets": 166, + "orbit_sizes": { + "1": 6, + "3": 42, + "6": 118 + } + }, + "all_basis": { + "alphabets": 166, + "completed": 166, + "searched_words": 7406643, + "states": [ + 7406643, + 24410375, + 59745229, + 89537683 + ], + "terminals": 262735, + "robust": 0 + }, + "selected_rational_field_words": 48, + "source_manifest_sha256": "f6936c24dcabf23a7d07e85fe1f098ba649a42913f4d545e6062a9de37fa1541", + "scope": "Restricted clean endpoint; frame spans five and six remain open." +} diff --git a/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt new file mode 100644 index 0000000000..9379b3ba1f --- /dev/null +++ b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/ALPHABETS.txt @@ -0,0 +1,166 @@ +1 1 2 2 4 4 8 8 1 1 2 2 4 4 8 8 +1 1 2 2 4 4 8 8 1 1 2 2 4 12 12 8 +1 1 2 2 4 4 8 8 1 1 2 2 8 12 12 4 +1 1 2 2 4 4 8 8 1 1 2 6 6 4 8 8 +1 1 2 2 4 4 8 8 1 1 2 6 6 12 14 8 +1 1 2 2 4 4 8 8 1 1 2 6 8 12 14 4 +1 1 2 2 4 4 8 8 1 1 2 10 4 12 14 8 +1 1 2 2 4 4 8 8 1 1 2 10 10 12 14 4 +1 1 2 2 4 4 8 8 1 1 2 14 6 4 10 8 +1 1 2 2 4 4 8 8 1 1 2 14 6 12 12 8 +1 1 2 2 4 4 8 8 1 1 2 14 10 12 12 4 +1 1 2 2 4 4 8 8 1 1 6 2 8 14 12 6 +1 1 2 2 4 4 8 8 1 1 6 10 10 6 14 14 +1 1 2 2 4 4 8 8 1 1 8 10 10 6 14 4 +1 1 2 2 4 4 8 8 1 1 8 14 10 2 12 4 +1 1 2 2 4 4 8 8 1 1 10 12 12 10 14 14 +1 1 2 2 4 4 8 8 1 3 3 2 4 12 12 8 +1 1 2 2 4 4 8 8 1 3 3 2 8 12 12 4 +1 1 2 2 4 4 8 8 1 3 3 6 7 4 8 8 +1 1 2 2 4 4 8 8 1 3 3 6 7 12 15 8 +1 1 2 2 4 4 8 8 1 3 3 6 8 12 15 4 +1 1 2 2 4 4 8 8 1 3 3 10 4 12 15 8 +1 1 2 2 4 4 8 8 1 3 3 10 11 12 15 4 +1 1 2 2 4 4 8 8 1 3 3 14 7 4 11 8 +1 1 2 2 4 4 8 8 1 3 3 14 7 12 12 8 +1 1 2 2 4 4 8 8 1 3 3 14 11 12 12 4 +1 1 2 2 4 4 8 8 1 3 4 6 7 2 8 8 +1 1 2 2 4 4 8 8 1 3 4 6 7 10 15 8 +1 1 2 2 4 4 8 8 1 3 4 6 8 10 15 2 +1 1 2 2 4 4 8 8 1 3 4 12 12 10 15 2 +1 1 2 2 4 4 8 8 1 3 4 14 7 2 12 8 +1 1 2 2 4 4 8 8 1 3 4 14 7 10 11 8 +1 1 2 2 4 4 8 8 1 3 4 14 11 2 12 10 +1 1 2 2 4 4 8 8 1 3 7 2 8 14 12 6 +1 1 2 2 4 4 8 8 1 3 7 4 8 14 11 6 +1 1 2 2 4 4 8 8 1 3 7 10 11 6 15 14 +1 1 2 2 4 4 8 8 1 3 7 12 12 6 15 14 +1 1 2 2 4 4 8 8 1 3 8 10 11 6 15 4 +1 1 2 2 4 4 8 8 1 3 8 12 12 6 15 2 +1 1 2 2 4 4 8 8 1 3 8 14 11 2 12 4 +1 1 2 2 4 4 8 8 1 3 11 12 12 10 15 14 +1 1 2 2 4 4 8 8 1 7 3 2 5 4 8 8 +1 1 2 2 4 4 8 8 1 7 3 2 5 12 13 8 +1 1 2 2 4 4 8 8 1 7 3 2 8 12 13 4 +1 1 2 2 4 4 8 8 1 7 3 6 6 4 8 8 +1 1 2 2 4 4 8 8 1 7 3 6 6 12 14 8 +1 1 2 2 4 4 8 8 1 7 3 6 8 12 14 4 +1 1 2 2 4 4 8 8 1 7 3 10 5 12 14 8 +1 1 2 2 4 4 8 8 1 7 3 10 11 12 14 4 +1 1 2 2 4 4 8 8 1 7 3 14 6 4 11 8 +1 1 2 2 4 4 8 8 1 7 3 14 6 12 13 8 +1 1 2 2 4 4 8 8 1 7 3 14 11 12 13 4 +1 1 2 2 4 4 8 8 1 7 6 2 8 14 13 6 +1 1 2 2 4 4 8 8 1 7 6 10 11 6 14 14 +1 1 2 2 4 4 8 8 1 7 8 10 11 6 14 4 +1 1 2 2 4 4 8 8 1 7 8 14 11 2 13 4 +1 1 2 2 4 4 8 8 1 7 11 12 13 10 14 14 +1 1 2 2 4 4 8 8 1 9 2 10 4 12 15 8 +1 1 2 2 4 4 8 8 1 9 2 10 11 12 15 4 +1 1 2 2 4 4 8 8 1 9 2 14 6 4 11 8 +1 1 2 2 4 4 8 8 1 9 2 14 6 12 13 8 +1 1 2 2 4 4 8 8 1 9 2 14 11 12 13 4 +1 1 2 2 4 4 8 8 1 9 6 2 9 14 13 6 +1 1 2 2 4 4 8 8 1 9 6 10 11 6 15 14 +1 1 2 2 4 4 8 8 1 9 9 10 11 6 15 4 +1 1 2 2 4 4 8 8 1 9 9 14 11 2 13 4 +1 1 2 2 4 4 8 8 1 9 11 12 13 10 15 14 +1 1 2 2 4 4 8 8 1 11 3 2 9 12 13 4 +1 1 2 2 4 4 8 8 1 11 3 6 7 4 9 8 +1 1 2 2 4 4 8 8 1 11 3 6 7 12 14 8 +1 1 2 2 4 4 8 8 1 11 3 6 9 12 14 4 +1 1 2 2 4 4 8 8 1 11 3 10 10 12 14 4 +1 1 2 2 4 4 8 8 1 11 3 14 7 4 10 8 +1 1 2 2 4 4 8 8 1 11 3 14 7 12 13 8 +1 1 2 2 4 4 8 8 1 11 3 14 10 12 13 4 +1 1 2 2 4 4 8 8 1 11 4 14 7 2 13 8 +1 1 2 2 4 4 8 8 1 11 4 14 7 10 10 8 +1 1 2 2 4 4 8 8 1 11 4 14 10 2 13 10 +1 1 2 2 4 4 8 8 1 11 7 2 9 14 13 6 +1 1 2 2 4 4 8 8 1 11 7 4 9 14 10 6 +1 1 2 2 4 4 8 8 1 11 7 10 10 6 14 14 +1 1 2 2 4 4 8 8 1 11 7 12 13 6 14 14 +1 1 2 2 4 4 8 8 1 11 9 10 10 6 14 4 +1 1 2 2 4 4 8 8 1 11 9 12 13 6 14 2 +1 1 2 2 4 4 8 8 1 11 9 14 10 2 13 4 +1 1 2 2 4 4 8 8 1 11 10 12 13 10 14 14 +1 1 2 2 4 4 8 8 1 15 3 2 5 4 9 8 +1 1 2 2 4 4 8 8 1 15 3 2 5 12 12 8 +1 1 2 2 4 4 8 8 1 15 3 2 9 12 12 4 +1 1 2 2 4 4 8 8 1 15 3 6 6 4 9 8 +1 1 2 2 4 4 8 8 1 15 3 6 6 12 15 8 +1 1 2 2 4 4 8 8 1 15 3 6 9 12 15 4 +1 1 2 2 4 4 8 8 1 15 3 10 5 12 15 8 +1 1 2 2 4 4 8 8 1 15 3 10 10 12 15 4 +1 1 2 2 4 4 8 8 1 15 3 14 6 4 10 8 +1 1 2 2 4 4 8 8 1 15 3 14 6 12 12 8 +1 1 2 2 4 4 8 8 1 15 3 14 10 12 12 4 +1 1 2 2 4 4 8 8 1 15 6 2 9 14 12 6 +1 1 2 2 4 4 8 8 1 15 6 10 10 6 15 14 +1 1 2 2 4 4 8 8 1 15 9 10 10 6 15 4 +1 1 2 2 4 4 8 8 1 15 9 14 10 2 12 4 +1 1 2 2 4 4 8 8 1 15 10 12 12 10 15 14 +1 1 2 2 4 4 8 8 3 1 6 3 8 15 12 7 +1 1 2 2 4 4 8 8 3 1 6 4 8 15 10 7 +1 1 2 2 4 4 8 8 3 1 6 11 10 7 14 15 +1 1 2 2 4 4 8 8 3 1 6 12 12 7 14 15 +1 1 2 2 4 4 8 8 3 1 8 11 10 7 14 4 +1 1 2 2 4 4 8 8 3 1 8 12 12 7 14 3 +1 1 2 2 4 4 8 8 3 1 8 15 10 3 12 4 +1 1 2 2 4 4 8 8 3 1 10 12 12 11 14 15 +1 1 2 2 4 4 8 8 3 5 5 3 7 7 8 8 +1 1 2 2 4 4 8 8 3 5 5 3 7 15 15 8 +1 1 2 2 4 4 8 8 3 5 5 3 8 15 15 7 +1 1 2 2 4 4 8 8 3 5 5 11 7 7 13 8 +1 1 2 2 4 4 8 8 3 5 5 11 7 15 10 8 +1 1 2 2 4 4 8 8 3 5 5 11 10 7 13 15 +1 1 2 2 4 4 8 8 3 5 5 12 13 15 15 7 +1 1 2 2 4 4 8 8 3 5 7 4 8 11 10 3 +1 1 2 2 4 4 8 8 3 5 7 7 8 11 13 3 +1 1 2 2 4 4 8 8 3 5 7 12 13 3 15 11 +1 1 2 2 4 4 8 8 3 5 7 15 10 3 15 11 +1 1 2 2 4 4 8 8 3 5 8 11 10 7 13 4 +1 1 2 2 4 4 8 8 3 5 8 12 13 3 15 7 +1 1 2 2 4 4 8 8 3 5 8 15 10 3 15 4 +1 1 2 2 4 4 8 8 3 5 10 12 13 15 15 11 +1 1 2 2 4 4 8 8 3 9 6 11 9 7 13 15 +1 1 2 2 4 4 8 8 3 9 6 12 13 15 15 7 +1 1 2 2 4 4 8 8 3 9 9 3 11 15 15 4 +1 1 2 2 4 4 8 8 3 9 9 7 11 11 13 4 +1 1 2 2 4 4 8 8 3 9 9 12 13 15 15 11 +1 1 2 2 4 4 8 8 3 9 11 12 13 3 15 7 +1 1 2 2 4 4 8 8 3 13 5 11 7 7 14 8 +1 1 2 2 4 4 8 8 3 13 5 11 7 15 9 8 +1 1 2 2 4 4 8 8 3 13 5 11 9 7 14 15 +1 1 2 2 4 4 8 8 3 13 7 4 9 3 11 11 +1 1 2 2 4 4 8 8 3 13 7 7 11 11 14 3 +1 1 2 2 4 4 8 8 3 13 7 12 12 11 14 3 +1 1 2 2 4 4 8 8 3 13 7 15 9 3 12 11 +1 1 2 2 4 4 8 8 3 13 9 3 11 15 12 4 +1 1 2 2 4 4 8 8 3 13 9 7 11 11 14 4 +1 1 2 2 4 4 8 8 3 13 9 12 12 11 14 15 +1 1 2 2 4 4 8 8 3 13 11 12 12 7 14 3 +1 1 2 2 4 4 8 8 7 1 8 11 10 6 14 5 +1 1 2 2 4 4 8 8 7 1 8 14 10 3 12 5 +1 1 2 2 4 4 8 8 7 1 10 13 12 11 14 14 +1 1 2 2 4 4 8 8 7 7 8 11 13 6 14 5 +1 1 2 2 4 4 8 8 7 7 11 11 13 13 14 14 +1 1 2 2 4 4 8 8 7 9 9 3 11 6 15 13 +1 1 2 2 4 4 8 8 7 9 9 14 11 11 13 13 +1 1 2 2 4 4 8 8 7 9 11 5 13 3 15 14 +1 1 2 2 4 4 8 8 7 15 9 3 12 6 15 13 +1 1 2 2 4 4 8 8 7 15 9 14 10 13 12 11 +1 1 2 2 4 4 8 8 8 9 9 3 11 6 15 4 +1 1 2 2 4 4 8 8 8 9 9 7 11 2 13 4 +1 1 2 2 4 4 8 8 8 9 11 5 13 3 15 7 +1 1 2 2 4 4 8 8 8 11 9 1 10 6 14 4 +1 1 2 2 4 4 8 8 8 11 9 7 13 6 14 2 +1 1 2 2 4 4 8 8 8 15 9 1 10 2 12 4 +1 1 2 2 4 4 8 8 8 15 9 3 12 6 15 2 +1 1 2 2 4 4 8 8 9 1 10 13 12 11 14 15 +1 1 2 2 4 4 8 8 9 3 11 15 12 9 15 13 +1 1 2 2 4 4 8 8 9 7 11 11 13 13 14 9 +1 1 2 2 4 4 8 8 9 10 10 9 11 15 15 4 +1 1 2 2 4 4 8 8 9 10 10 13 11 11 14 4 +1 1 2 2 4 4 8 8 9 10 11 6 14 9 15 13 +1 1 2 2 4 4 8 8 11 12 13 10 14 9 15 7 diff --git a/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/RESULT.txt b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/RESULT.txt new file mode 100644 index 0000000000..b0dff35fba --- /dev/null +++ b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/RESULT.txt @@ -0,0 +1,72 @@ +EXACT RESULT FOR A FINITE CLEAN-ANCILLA CLASS + +There is no eight-call word in the class below. This result does not +exclude arbitrary four-register scalar words. + +The endpoint has three active outputs. Their address operators are +three invertible lower-triangular rational 3 by 3 frames. A fourth +input starts at zero. Its final output can be discarded. + +Fix the coordinate basis I of F_2^4. Let B be any binary basis. The +allowed scalar projectors are the four coordinate projectors and +the four projectors onto the basis vectors of B along their dual +covectors. The word can use any eight ordered factors from this union, +with repeated projectors. Each paid address frame can be any nonzero +rational rank-one 3 by 3 matrix. There is no bound on its entries. + +The catalogue has 840 unordered binary bases. Permutations of the +three active coordinates leave 166 basis orbits. The fourth coordinate +stays fixed. All 166 alphabets were checked. Fixing the first basis to +I is part of the stated class. It is not a normalization of an arbitrary +pair of bases under a general change of scalar coordinates. + +The scalar generator uses two necessary filters. Each of the seven +active binary probes must touch at least three calls on each side. +Also, adjacent factors with commuting scalar projectors can be sorted. +The generator retains one least word in each such trace class. It uses +no reversal or inverse symmetry. The two distance arrays are separate; +the projectors need not be symmetric. + +Every remaining scalar word goes through a complete relation search. +The clean version of the span-four lemma requires rational frame span +at least five. There are therefore at most three independent relations +among eight frames. The search branches on exact collisions of subset +sums. It requires zero active off-diagonal entries and one monomial in +each active diagonal entry. It imposes no other condition on the fourth +row or column. A terminal is rejected only after a target is proved to +lie in the span of at most two paid frames, or an earlier necessary +condition fails. + +The field calculation uses F_101 as an exact representation of these +rational rank tests. Each tested minor has, after expansion along any +coordinate rows, at most four rows with entries in {-1,0,1}. Its absolute +determinant is at most 16. Rational echelon entries for the three original +relation rows have numerators and denominators at most four. Thus the +field calculation preserves the needed zero tests and permits unique +rational reconstruction before the parity test. The calculation does +not reduce physical rational frame entries modulo two. + +Result: + + scalar trace words checked: 7,406,643 + relation states checked: 181,099,930 + active monomial terminals: 262,735 + terminals without rank obstacle: 0 + basis alphabets completed: 166 + +The exact counts are in ALL-BASIS-SUMMARY.json. The per-alphabet records +are in all-basis-results/. Reproduction uses ALPHABETS.txt, two_bases.cpp, +and run_two_bases.py. The C++ relation core was copied from the separate +bit8 agent's clean_f101.cpp. Its scalar driver was replaced for the +present class. The smaller Fraction implementation is search.py. + +Independent checks: a second agent reconstructed the 840 bases, their +166 active-coordinate orbits, and the earlier 17,106 layer jobs. It also +compared the Fraction and field engines on 48 selected nonsymmetric +words. All terminal and survivor counts agreed on those words. This is +a selected-case second-engine check, not a second full replay of all +7,406,643 words. See ../rank-independent/clean-audit/. + +No positive supplier gain follows from this result. The wider clean +ancilla problem, with arbitrary scalar rank-one idempotents, remains +open in this work. diff --git a/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/run_two_bases.py b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/run_two_bases.py new file mode 100644 index 0000000000..7ea2e7703c --- /dev/null +++ b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/run_two_bases.py @@ -0,0 +1,40 @@ +"""Run all basis alphabets with three independent worker processes.""" +from concurrent.futures import ThreadPoolExecutor, as_completed +import json +from pathlib import Path +import subprocess +import time + + +folder = Path(__file__).resolve().parent +result_folder = folder/'all-basis-results' + + +def run(index): + out = result_folder/f'{index:03d}.json' + log = result_folder/f'{index:03d}.log' + with log.open('w') as stream: + subprocess.run([str(folder/'two_bases'), str(folder/'ALPHABETS.txt'), + str(index), str(out)], check=True, stderr=stream) + return json.loads(out.read_text()) + + +if __name__ == '__main__': + result_folder.mkdir(exist_ok=True) + count = len((folder/'ALPHABETS.txt').read_text().splitlines()) + start = time.monotonic() + results = [] + with ThreadPoolExecutor(max_workers=3) as executor: + jobs = [executor.submit(run, index) for index in range(count)] + for future in as_completed(jobs): + result = future.result() + results.append(result) + summary = dict(alphabets=count, completed=len(results), + searched_words=sum(r['searched_words'] for r in results), + states=[sum(r['states'][k] for r in results) for k in range(4)], + terminals=sum(r['terminals'] for r in results), + robust=sum(r['robust'] for r in results), + seconds=time.monotonic()-start, + results=sorted(results, key=lambda r:r['basis'])) + (folder/'ALL-BASIS-SUMMARY.json').write_text(json.dumps(summary,indent=2)+'\n') + print(json.dumps({k:v for k,v in summary.items() if k!='results'}),flush=True) diff --git a/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/search.py b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/search.py new file mode 100644 index 0000000000..1cf74f802c --- /dev/null +++ b/research/bit-clean-extra-register/sources/doubling-architecture/clean-ancilla/search.py @@ -0,0 +1,84 @@ +"""Search a finite scalar ansatz with one clean discarded ancilla.""" +from pathlib import Path +import importlib.util +import itertools +import json +import time + +src=Path(__file__).resolve().parents[2]/'four-register/dirty_ancilla.py' +spec=importlib.util.spec_from_file_location('returned_engine',src) +d=importlib.util.module_from_spec(spec);spec.loader.exec_module(d) +OFF=sum(1<<(4*i+j) for i in range(3) for j in range(3) if i!=j) +MAXREL=3 + + +def solve(word): + poly=d.polynomial(word);seen=set();found=[] + first=[sum(((d.outer(x,y)>>bit)&1)<>bit&1] + stats={'nodes':0,'terminals':0,'low_rank_targets':0,'parity_prunes':0} + def rec(state): + if state in seen:return False + seen.add(state);stats['nodes']+=1 + if d.gf2_rank(first+[d.primitive_parity(r) for r in state])>MAXREL: + stats['parity_prunes']+=1;return False + grouped={} + for s,c in poly: + key=d.rep(state,d.BITS[s]);grouped[key]=grouped.get(key,0)^c + terms=[(v,c) for v,c in grouped.items() if c] + bad=[] + for i in range(3): + for j in range(3): + vv=[v for v,c in terms if c>>(4*i+j)&1] + if i!=j and vv:bad.append((False,vv)) + elif i==j and len(vv)!=1:bad.append((True,vv)) + if not bad: + stats['terminals']+=1 + targets=[next(v for v,c in terms if c>>(5*i)&1) for i in range(3)] + for t in targets: + if any(not any(d.rep(d.rref(state+(d.UNIT[a],d.UNIT[b])),t)) for a,b in itertools.combinations(range(8),2)): + stats['low_rank_targets']+=1;return False + found.append({'relations':[[str(x) for x in r] for r in state], + 'targets':[[str(x) for x in r] for r in targets]}) + return True + if len(state)>=MAXREL:return False + diagonal,vv=min(bad,key=lambda x:len(x[1])) + if len(vv)<2:return False + pairs=(((vv[0],v) for v in vv[1:]) if not diagonal else + itertools.chain(((vv[0],v) for v in vv[1:]),((vv[1],v) for v in vv[2:]))) + for a,b in pairs: + nxt=d.add(state,tuple(x-y for x,y in zip(a,b))) + if nxt is not None and len(nxt)<=MAXREL and rec(nxt):return True + return False + rec(()) + return {'word':word,'stats':stats,'found':found} + + +def canonical(layers): + choices=[] + # Fix the clean fourth coordinate. Reversal need not preserve the model. + for p3 in itertools.permutations(range(3)): + p=p3+(3,) + ls=[tuple(sorted((d.permute_vector(x,p),d.permute_vector(y,p)) for x,y in layer)) for layer in layers] + choices.append(tuple(pair for layer in ls for pair in layer)) + return min(choices) + + +def main(): + I=[(1< +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using Row = std::array; + +int prod[101][101], inverse[101], num[101], den[101], outer_table[16][16]; +constexpr int ID = 33825; +const int OFF_BITS[6] = {1,2,4,6,8,9}; + +int minus_product(int a, int t, int b) { + int q = a - prod[t][b]; + return q < 0 ? q + 101 : q; +} + +struct Basis { + std::array a{}; + std::array p{}; + int n = 0; + + bool operator==(const Basis& b) const { return a == b.a; } +}; + +struct BasisHash { + size_t operator()(const Basis& b) const { + size_t h = 0xcbf29ce484222325ULL; + for (const auto& r : b.a) + for (int x : r) + h = (h ^ x) * 0x100000001b3ULL; + return h; + } +}; + +Row subset(int m) { + Row v{}; + for (int i = 0; i < 8; ++i) + v[i] = (m >> i) & 1; + return v; +} + +Row residual(Row v, const Basis& b) { + for (int i = 0; i < b.n; ++i) { + int t = v[b.p[i]]; + if (t) + for (int j = b.p[i]; j < 8; ++j) + v[j] = minus_product(v[j], t, b.a[i][j]); + } + return v; +} + +Basis insert(Basis b, Row v) { + v = residual(v, b); + int p = 0; + while (p < 8 && !v[p]) + ++p; + if (p == 8) + return b; + if (b.n == 3) + throw std::logic_error("A state has too many relations"); + + int q = inverse[v[p]]; + for (int j = p; j < 8; ++j) + v[j] = prod[v[j]][q]; + for (int i = 0; i < b.n; ++i) { + int t = b.a[i][p]; + if (t) + for (int j = p; j < 8; ++j) + b.a[i][j] = minus_product(b.a[i][j], t, v[j]); + } + int at = b.n; + while (at && b.p[at - 1] > p) { + b.a[at] = b.a[at - 1]; + b.p[at] = b.p[at - 1]; + --at; + } + b.a[at] = v; + b.p[at] = p; + ++b.n; + return b; +} + +int binrank(const std::vector& rows) { + int b[8]{}, n = 0; + for (int v : rows) { + for (int k = 7; k >= 0; --k) { + if (!((v >> k) & 1)) + continue; + if (b[k]) { + v ^= b[k]; + } else { + b[k] = v; + ++n; + break; + } + } + } + return n; +} + +int primitive_parity(const Row& r) { + int d = 1; + for (int x : r) { + if (!den[x]) + throw std::logic_error("Rational reconstruction exceeds the proved bound"); + d = std::lcm(d, den[x]); + } + int v[8], g = 0; + for (int i = 0; i < 8; ++i) { + v[i] = num[r[i]] * (d / den[r[i]]); + g = std::gcd(g, std::abs(v[i])); + } + int bits = 0; + for (int i = 0; i < 8; ++i) + bits |= (std::abs(v[i] / g) & 1) << i; + return bits; +} + +struct GeneralBasis { + std::array a{}; + std::array p{}; + int n = 0; + + explicit GeneralBasis(const Basis& b) { + n = b.n; + for (int i = 0; i < n; ++i) { + a[i] = b.a[i]; + p[i] = b.p[i]; + } + } + + bool add(Row v) { + for (int i = 0; i < n; ++i) { + int t = v[p[i]]; + if (t) + for (int j = p[i]; j < 8; ++j) + v[j] = minus_product(v[j], t, a[i][j]); + } + int j = 0; + while (j < 8 && !v[j]) + ++j; + if (j == 8) + return false; + int q = inverse[v[j]]; + for (int k = j; k < 8; ++k) + v[k] = prod[v[k]][q]; + int at = n; + while (at && p[at - 1] > j) { + a[at] = a[at - 1]; + p[at] = p[at - 1]; + --at; + } + a[at] = v; + p[at] = j; + ++n; + return true; + } +}; + +bool target_small(int mask, const Basis& b) { + if (__builtin_popcount(static_cast(mask)) <= 2) + return true; + for (int i = 0; i < 8; ++i) { + for (int j = i + 1; j < 8; ++j) { + GeneralBasis g(b); + g.add(subset(1 << i)); + g.add(subset(1 << j)); + if (!g.add(subset(mask))) + return true; + } + } + return false; +} + +struct Group { + uint64_t key; + int mask, coefficient; +}; + +struct Search { + std::array word; + int ancillas = 15; + uint64_t index = 0; + std::array diagonal{}; + std::vector> terms; + std::vector off; + std::unordered_set visited; + uint64_t states[4]{}, parity = 0, zero = 0, terminals = 0; + uint64_t robust = 0, not_monomial = 0; + + void start() { + int coefficients[256]{}; + coefficients[0] = ID; + for (int j = 0; j < 8; ++j) { + int x = 0, y = 0; + for (int i = 0; i < 4; ++i) { + int row = (word[j] >> (4*i)) & 15; + if (row) { + if (y && y != row) throw std::logic_error("A projector has rank greater than one"); + y = row; x |= 1 << i; + } + } + if (!x || !y || !(__builtin_parity(unsigned(x&y)))) + throw std::logic_error("A projector is not a nonzero rank-one idempotent"); + for (int m = 0; m < (1 << j); ++m) { + int c = coefficients[m], u = 0; + for (int i = 0; i < 4; ++i) + u |= __builtin_parity(unsigned(((c >> (4*i)) & 15) & x)) << i; + int right = outer_table[u][y]; + coefficients[m] = c ^ right; + coefficients[m | (1 << j)] = right; + } + } + for (int m = 0; m < 256; ++m) + if (coefficients[m]) + terms.emplace_back(m, coefficients[m]); + for (int bit : OFF_BITS) { + int v = 0; + for (int j = 0; j < 8; ++j) + v |= ((word[j] >> bit) & 1) << j; + off.push_back(v); + } + for (int w = 0; w < 4; ++w) + for (int j = 0; j < 8; ++j) + diagonal[w] |= ((word[j] >> (5*w)) & 1) << j; + go(Basis{}); + } + + int allowed(const Basis& b) const { + auto ps = off; + for (int i = 0; i < b.n; ++i) ps.push_back(primitive_parity(b.a[i])); + return binrank(ps) <= 3; + } + + bool nonzero_frames(const Basis& b) const { + for (int i = 0; i < b.n; ++i) { + int count = 0; + for (int v : b.a[i]) count += v != 0; + if (count == 1) return false; + } + return true; + } + + void go(const Basis& b) { + if (!visited.insert(b).second) + return; + ++states[b.n]; + int possible = allowed(b); + if (!possible) { ++parity; return; } + if (!nonzero_frames(b)) { ++zero; return; } + + std::unordered_map positions; + std::vector groups; + positions.reserve(terms.size()); + groups.reserve(terms.size()); + for (auto [mask, c] : terms) { + auto v = residual(subset(mask), b); + uint64_t key = 0; + for (int j = 0; j < 8; ++j) + key |= uint64_t(v[j]) << (7 * j); + auto [it, fresh] = positions.emplace(key, int(groups.size())); + if (fresh) + groups.push_back({key, mask, c}); + else + groups[it->second].coefficient ^= c; + } + + std::vector active; + int counts[16]{}; + for (auto g : groups) { + if (g.coefficient) { + active.push_back(g); + for (int bit : OFF_BITS) + counts[bit] += (g.coefficient >> bit) & 1; + } + } + int chosen = -1; + for (int bit : OFF_BITS) + if (counts[bit] && (chosen < 0 || counts[bit] < counts[chosen])) + chosen = bit; + + if (chosen < 0) { + int target[3] = {-1,-1,-1}; + std::vector need; + for (int w=0; w<3; ++w) { + std::vector diagonal_terms; + for (auto g:active) if ((g.coefficient >> (5*w)) & 1) diagonal_terms.push_back(g); + if (diagonal_terms.empty()) throw std::logic_error("An active diagonal has zero augmentation"); + if (diagonal_terms.size()==1) target[w]=diagonal_terms[0].mask; + else if (need.empty() || diagonal_terms.size()>k)&1)-((need[j].mask>>k)&1); + v[k]=t<0?100:t; + } + auto c=insert(b,v); + if (c.n!=b.n+1) throw std::logic_error("A diagonal partner is in the same group"); + go(c); + } + return; + } + ++terminals; + for (int w=0;w<3;++w) if (target_small(target[w],b)) return; + ++robust; + std::cerr << "ROBUST " << index << " word"; + for (int n:word) std::cerr << ' ' << n; + std::cerr << " targets"; + for(int t:target)std::cerr << ' ' << t; + std::cerr << " relations"; + for(int i=0;i> chosen) & 1)) + ++first; + for (int j = first + 1; j < int(active.size()); ++j) { + if ((active[j].coefficient >> chosen) & 1) { + Row v{}; + for (int k = 0; k < 8; ++k) { + int t = ((active[first].mask >> k) & 1) - + ((active[j].mask >> k) & 1); + v[k] = t < 0 ? 100 : t; + } + auto c = insert(b, v); + if (c.n != b.n + 1) + throw std::logic_error("A partner is already in the same group"); + go(c); + } + } + } +}; + +void setup() { + for (int a = 0; a < 101; ++a) + for (int b = 0; b < 101; ++b) + prod[a][b] = (a * b) % 101; + for (int a = 1; a < 101; ++a) + for (int b = 1; b < 101; ++b) + if (prod[a][b] == 1) + inverse[a] = b; + for (int d = 1; d <= 5; ++d) { + for (int n = -5; n <= 5; ++n) { + if (std::gcd(std::abs(n), d) == 1) { + int x = prod[(n + 101) % 101][inverse[d]]; + if (den[x] && (num[x] != n || den[x] != d)) + throw std::logic_error("Rational reconstruction is not unique"); + num[x] = n; + den[x] = d; + } + } + } + for (int x = 0; x < 16; ++x) + for (int y = 0; y < 16; ++y) + for (int i = 0; i < 4; ++i) + if ((x >> i) & 1) outer_table[x][y] |= y << (4*i); +} + +int main(int argc,char**argv) { + try { + if(argc!=4)throw std::runtime_error("Usage: two_bases ALPHABETS INDEX OUTPUT_JSON"); + setup(); + std::ifstream alphabet_file(argv[1]); + int index=std::stoi(argv[2]); + std::vector> alphabet; + for(int line=0;line<=index;++line) { + alphabet.clear(); + for(int j=0;j<8;++j) { + int x,y; + if(!(alphabet_file>>x>>y))throw std::runtime_error("Cannot read alphabet"); + alphabet.emplace_back(x,y); + } + } + std::sort(alphabet.begin(),alphabet.end()); + alphabet.erase(std::unique(alphabet.begin(),alphabet.end()),alphabet.end()); + int count=int(alphabet.size()); + int matrices[8],hit[8][14],labels[8]{},distance[14]{}; + bool commutes[8][8]; + for(int j=0;jvoid { + if(stopped)return; + ++prefixes; + for(int r=0;r<14;++r)if(distance[r]+8-depth<3)return; + if(depth==8) { + ++leaves; + Search search;search.index=words; + for(int j=0;j<8;++j)search.word[j]=matrices[labels[j]]; + search.start();++words; + for(int k=0;k<4;++k)states[k]+=search.states[k]; + terminals+=search.terminals;robust+=search.robust;parity+=search.parity;zero+=search.zero; + if(search.robust)stopped=true; + return; + } + for(int j=0;j=0;--k) { + if(!commutes[labels[k]][j])break; + if(labels[k]>j){normal=false;break;} + } + if(!normal)continue; + labels[depth]=j; + for(int r=0;r<14;++r)distance[r]+=hit[j][r]; + self(self,depth+1); + for(int r=0;r<14;++r)distance[r]-=hit[j][r]; + } + }; + walk(walk,0); + double seconds=std::chrono::duration(std::chrono::steady_clock::now()-begun).count(); + std::ofstream out(argv[3]);if(!out)throw std::runtime_error("Cannot open output"); + out << "{\"basis\":"<> x >> y) { + Search s; + s.index = index; + s.word[0] = outer_table[x][y]; + for (int j = 1; j < 8; ++j) { + if (!(std::cin >> x >> y)) return 2; + s.word[j] = outer_table[x][y]; + } + s.start(); + std::cout << "{\"case\":" << index++ << ",\"terminals\":" << s.terminals + << ",\"robust\":" << s.robust << ",\"states\":[" + << s.states[0] << ',' << s.states[1] << ',' << s.states[2] + << ',' << s.states[3] << "]}\n"; + } +} diff --git a/research/bit-clean-extra-register/sources/four-register/CLEAN-ONE-RELATION.txt b/research/bit-clean-extra-register/sources/four-register/CLEAN-ONE-RELATION.txt new file mode 100644 index 0000000000..2d0d63a6c0 --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/CLEAN-ONE-RELATION.txt @@ -0,0 +1,140 @@ +One-relation reduction for a clean register +========================================== + +Statement +--------- +Consider eight nonzero rank-one rational 3 by 3 paid frames. Let the +active block of the scalar product be diag([C_1],[C_2],[C_3]), where +each C_i is invertible and lower triangular. Other input registers +start at zero, and their outputs are unused. + +If the paid-frame span has dimension eight, no such word exists. +If it has dimension seven, every paid scalar projector must have zero +active off-diagonal entries. The latter conclusion reduces this case +to the zero-active-off-pattern alphabet. It does not by itself exclude +that alphabet. + +Small active-target bounds +-------------------------- +One active invertible target needs at least three calls, regardless +of the number of clean registers. Its frame is in the span of all +paid rank-one frames, and fewer than three cannot span a rank-three +matrix. + +Two active invertible lower-triangular targets need at least six calls, +again with any number of clean registers. With at most five calls, a +frame span of dimension at most four is covered by CLEAN-SPAN-FOUR.txt. +The only other case has five independent frames. Each active target +then has one unique subset-sum exponent. Differentiate the formal +active-block identity at all variables equal to one. Each compressed +scalar projector is diagonal, and it has rank at most one. Thus each +paid variable occurs in at most one target. Rank subadditivity requires +at least three variables in each of the two targets, for a total of six. + +Independent frames and a long relation coefficient +------------------------------------------------- +For eight independent frames, the same differentiation argument gives +at least nine calls for three active targets. + +At frame span seven, the integer relation lattice has one primitive +generator r. If some |r_j| is at least two, no distinct subsets of the +paid frames have the same sum. Any subset difference has entries in +{-1,0,1}, whereas every nonzero integer multiple of r has an entry of +absolute value at least two. The same unique-subset differentiation +argument therefore again gives at least nine calls. + +The remaining relation has entries in {-1,0,1}. Let S be its nonzero +support. The Laurent ideal of relations is generated by + + g = product(t_j : r_j=1) - product(t_j : r_j=-1). + +This follows by extending the primitive vector r to an integer basis. +Each active target has a representative monomial t^(q_w), where q_w +is a subset indicator. The active-block polynomial minus this target +diagonal is divisible entrywise by g. + +Differentiate at all t_j=1 over F_2. The derivative of g in a variable +outside S is zero. Thus, for each j outside S, the active compression +of N_j is diag(q_1j,q_2j,q_3j). Its rank is at most one, so that variable +belongs to at most one target. On S, all active compressions have one +common off-diagonal pattern. + +Rank-one diagonal completions +----------------------------- +Let a nonzero off-diagonal pattern in a binary 3 by 3 matrix be fixed. +Consider all rank-one matrices with that pattern. One of the following +three descriptions applies. + +1. There is one matrix M. +2. All matrices are supported on one coordinate plane. +3. There are two matrices with one common coordinate image or one + common coordinate row. + +To prove the classification, the difference of any two completions is +a diagonal matrix of rank at most two. If some difference has rank two, +its image and row space are one coordinate plane. Both rank-one +summands have image and row space in that plane. No third completion +can have a nonzero remaining diagonal entry: that entry and an existing +nonzero off-diagonal entry would force a nonzero off-diagonal entry +outside the plane. + +Otherwise every nonzero difference has rank one and equals one E_ii. +There can be at most two distinct completions; differences at two +coordinates would give a rank-two difference. Two rank-one matrices +whose sum has rank one have a common image or a common row. Their sum +is E_ii, so that common image or row is coordinate i. This proves the +classification. + +Project onto the relation support +--------------------------------- +Suppose the common active off-diagonal pattern on S is nonzero. Set all +variables outside S to one. This operation is valid because the sole +relation is supported on S. The resulting subword still has a diagonal +active target. + +In case 1, the active image and row vectors of every factor on S are +the same x and y. Its active product has the form I+f x y^T. Since +x y^T has a nonzero off-diagonal entry and the active target is diagonal, +f=0. No target changes. + +In case 2, all active image and row vectors lie in the same coordinate +plane. The subword can change at most those two target roles. + +In case 3, the active product difference has its image in one coordinate +line, or its row space in one coordinate line. Since its active target +is diagonal, it can change at most that one target role. + +Let T be the set of possibly changed roles. Thus |T| is zero, one, or +two. For each role outside T, its original invertible target frame is a +sum of paid frames outside S. Each such target needs at least three of +those frames. The variable assignment above is disjoint between target +roles, so at least 3(3-|T|) outside calls are assigned to roles outside T. + +If T is empty, this already requires at least nine calls. Otherwise, +set those assigned outside variables to one and remove their factors. +This is a valid projection because the sole relation is still supported +on S. The target frames on T do not change: their monomial representatives +do not use any removed variable. Initialize the other registers at zero +and discard their outputs. The remaining circuit has |T| unchanged +invertible targets and at most + + 8 - 3(3-|T|) = 3|T|-1 + +calls. This contradicts the one- or two-active-target bound. Therefore +the common pattern on S must be zero. The pattern outside S was already +zero, which proves the claimed reduction. + +Verification status +------------------- +This is an analytical proof. It does not depend on a finite circuit +search. The open_pr_survey agent independently reviewed and approved +the completion classification, the compressed-product constraints, and +the removal of outside variables. A direct finite check of all 49 +nonzero binary rank-one active matrices also confirms the classification: +16 nonzero off-patterns have one completion, six have completions in a +coordinate plane, and six share a coordinate image or row. + +For exactly one clean extra register, a separate complete check excludes +the zero-active-off-pattern alphabet. See independent/clean-zero/PROOF.txt +and its result and independent audit. That finite result is required +to exclude span seven; the analytic reduction alone is not sufficient. diff --git a/research/bit-clean-extra-register/sources/four-register/CLEAN-SPAN-FOUR.txt b/research/bit-clean-extra-register/sources/four-register/CLEAN-SPAN-FOUR.txt new file mode 100644 index 0000000000..cadc8e98e9 --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/CLEAN-SPAN-FOUR.txt @@ -0,0 +1,86 @@ +Span-four bound with clean workspace +=================================== + +Claim +----- +Let the physical address dimension be three. Let W active scalar +registers have invertible lower-triangular rational target frames. +Permit any number of additional scalar registers with zero input and +unused output. If all paid rank-one frame matrices span a rational +space of dimension at most four, at least 3W calls are required. + +This claim does not require the complete scalar-register product to be +diagonal. Let J embed the active input and output registers. The required +condition is only + + J^T P J = diag([C_1],...,[C_W]). + +The extra rows and columns of P can be arbitrary. + +Compressed compact-rank bound +----------------------------- +For any selected nonzero projected frames, the full product has a compact +expansion P-I=X T Y^T. The matrix T is triangular with nonzero diagonal, +so it is invertible over the fraction field of the relevant group ring. +If the active block of the projected target is I, then + + (J^T X) T (Y^T J) = 0. + +If U calls remain, Sylvester's inequality gives + + rank(J^T X) + rank(Y^T J) <= U. + +The active projections of x and y can be zero. The bound remains valid. +For any other projection, the rank of the active target difference is +at most the rank of its active image vectors and at most the rank of its +active row vectors. No condition is imposed on the workspace blocks. + +Two-dimensional flag bound +-------------------------- +For a two-dimensional address block with lower-triangular targets, let +U be the calls whose upper frame entry is nonzero. Let r_X and r_Y be +the ranks of their active scalar image and row vectors. Upper-entry +projection has active target I, so the compressed bound gives +r_X+r_Y<=U. Let l_i count lower frames with nonzero diagonal entry i. +Each diagonal target difference has rank W, hence + + W <= r_X+l_i, W <= r_Y+l_i for i=0,1. + +A lower rank-one frame has at most one nonzero diagonal entry. Therefore + + 4W <= 2(r_X+r_Y+l_0+l_1) <= 2E. + +A two-dimensional physical block needs at least 2W calls. A one-dimensional +block needs at least W calls by the active target rank alone. + +Span-four reduction +------------------- +Choose three paid rank-one frames whose left vectors and right vectors +are each independent. They exist because the frame span contains an +invertible active target. Common rational row and column maps turn these +three frames into the diagonal coordinate matrices. A fourth basis +frame is u v^T. + +If all coordinates of u and v are nonzero, all rank-one frames in this +four-dimensional space lie on the four independent basis lines. Project +onto each line's coefficient. The active target rank gives a lower bound +on calls from that line. Each invertible target uses at least three +lines, so the sum of the four bounds is at least 3W. + +If a coordinate of u or v is zero, a simultaneous permutation makes the +physical frame space block upper triangular with diagonal blocks of +size at most two. Each rank-one frame has at most one nonzero diagonal +block. The active targets have invertible diagonal blocks. Their common +ratio flag descends to each invariant subquotient, so common row and +column maps within each block make its active targets lower triangular. +Assign each paid call to its nonzero diagonal block, if one exists. +The preceding one- and two-dimensional bounds sum to 3W. + +Thus a clean-workspace eight-call word for three active targets must +have frame span at least five. Its rational relation space has dimension +at most three. This claim does not permit reuse of the returned-register +scalar irreducibility or full off-diagonal pattern restrictions. + +Status: the root agent and the architecture agent independently reviewed +and approved the compressed-rank proof. The architecture agent is saving +a separate proof review. diff --git a/research/bit-clean-extra-register/sources/four-register/F101-ARITHMETIC.txt b/research/bit-clean-extra-register/sources/four-register/F101-ARITHMETIC.txt new file mode 100644 index 0000000000..ad49238fed --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/F101-ARITHMETIC.txt @@ -0,0 +1,64 @@ +Exact arithmetic for the eight-call returned-register search +============================================================ + +The state is a rational subspace of Q^8 with dimension at most three. +Each generating relation is one of these original rows: + +1. The difference of two subset indicator vectors. Each entry is -1, 0, + or 1. +2. At a diagonal terminal, the original subset indicator for the target + of the returned register. Each entry is 0 or 1. + +The second row is added only when the resulting rank is at most three. +The code uses an original monomial representative. It does not use a +reduced row as a new bounded generator. + +For r at most three, every r by r minor of these original rows has +absolute value at most floor(r^(r/2)), hence at most five. Cramer's rule +therefore writes each nonzero RREF entry as n/d with |n| at most five +and 1 <= d <= 5. Two such reduced fractions with the same image in +F_101 are equal: their cross difference has absolute value at most +50, which is less than 101. This proves the rational reconstruction +used for primitive-parity pruning. + +After reconstruction, the least common multiple of all denominators +is at most 60. Each integer numerator after this multiplication has +absolute value at most 300. Divide their greatest common divisor and +reduce modulo two. This is a primitive integer row of the rational +relation space. It lies in the saturated integer kernel of any actual +frame realization. The off-diagonal derivative rows and the returned +diagonal derivative row lie in that same kernel modulo two. Its binary +dimension is at most three. This proves the parity rejection rule. + +Every finite-field rank comparison agrees with the rational comparison. +A state has at most three original bounded generators. Testing a new +collision, a zero paid frame, or a returned target adds at most one +nonunit bounded row. The relevant minors have at most four nonunit +rows. Their absolute values are at most 16 by Hadamard's inequality. +Testing whether an active target lies in a two-frame span also adds +two coordinate unit rows. Expand a determinant along these unit rows; +the remaining minor still has at most four nonunit bounded rows. +Thus no nonzero minor relevant to a decision vanishes modulo 101. + +Two cached states have the same rational row space if and only if they +have the same row space over F_101. Each has rank at most three. If their +union has larger rank, at most four rows witness that fact. Those rows +are again original bounded generators, so the same minor bound applies. + +The code's GeneralBasis has capacity for six rows: three state rows, +two coordinate unit rows, and one target row. Forward elimination with +pivots in increasing order is sufficient for its rank tests. RREF is +used for cached states. + +The F101 source and these bounds passed an independent source audit by +the gaussian_escape agent. A separate integer engine checked the same +binary word files. The two engines found the same 538 rank-three word +IDs with diagonal terminals and the same terminal count for each ID. +Both found no accepted terminal. They also checked all 27156 rank-two +canonical orders and found no diagonal terminal. + +Seven additional controls check the formal polynomial search core. +They include acceptance after a required collision and acceptance after +a returned-target relation, as well as targeted rejection cases. These +are polynomial fixtures, not admissible paid-call circuit constructions. +Their separate scope is stated in dirty_f101_controls.py. diff --git a/research/bit-clean-extra-register/sources/four-register/FINAL-CLEAN-REPORT.txt b/research/bit-clean-extra-register/sources/four-register/FINAL-CLEAN-REPORT.txt new file mode 100644 index 0000000000..527f0f6fff --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/FINAL-CLEAN-REPORT.txt @@ -0,0 +1,127 @@ +CLEAN-REGISTER RESEARCH CHECKPOINT +================================== + +No eight-call construction was found. There is no new positive value +of kappa from this work. The general clean-register problem remains +open here, with the restrictions below. + +Exact model +----------- +There are three active scalar registers and one extra register. The +extra input is zero, and its output is unused. Only the upper-left +3 by 3 block of the full scalar product must equal + + diag([C_1],[C_2],[C_3]). + +The extra row and column are unrestricted. Each C_i is an invertible +lower-triangular rational 3 by 3 address frame. Each of the eight paid +factors is I+([A_j]-1)N_j. Each A_j is a nonzero rational rank-one frame; +its entries have no size bound and need not be lower triangular. Each +N_j is a binary rank-one idempotent on four scalar registers. The +coefficient ring is the additive group algebra F_2[M_3(Q)]. + +General restrictions +-------------------- +CLEAN-SPAN-FOUR.txt proves that paid-frame span at most four requires +at least nine calls. The proof permits any number of clean extra +registers. Its compact-product rank bounds use the active block only. +The root and architecture agents independently reviewed this extension. + +CLEAN-ONE-RELATION.txt proves that span eight is impossible, and that +span seven requires every paid projector to have zero off-diagonal +entries in its active block. The open_pr_survey agent independently +reviewed its rank-one completion classification and variable removal. +A direct enumeration also confirms all 28 nonzero completion patterns. + +The complete finite check below excludes the zero-pattern case for one +clean extra register. Its independent family and order audit passed. +These results leave only paid-frame spans five and six in the stated +four-register eight-call model. That is a restriction on an unresolved +problem, not a construction or a complete impossibility theorem. + +Complete zero-pattern case +-------------------------- +The full alphabet has 24 binary projectors. Necessary active distance +bounds reduce every eight-call word to 216 scalar multisets. The reviewer +gave a separate analytic proof of this restriction. Each multiset has +two calls from each of three active-diagonal families and one call from +each of two fixed helper-star directions. All factor orders were checked, +with only swaps of adjacent commuting projectors removed. No reversal +symmetry was used. + + Raw orders: 3,674,160 + Commuting normal forms: 314,666 + Relation states by rank: + 314,666; 1,005,125; 1,024,411; 2,160,151 + Active monomial terminals: 20,430 + Word IDs with such terminals: 17,799 + Terminals without a rank obstruction: 0 + +Two engines checked every saved word: one with primitive integer +relations, and one with F_101 and a proved bounded-minor correspondence +to rational arithmetic. After deterministic branch ordering, all chunk +counts and all terminal word/count rows are identical. Both algorithms +branch on subset-exponent collisions; the arithmetic implementations +are separate. This is not a separate mathematical proof of the branch +rule. That rule and the field bounds also received source review. + +Evidence: independent/clean-zero/PROOF.txt and RESULT.json. +Binary input SHA256: +07514db121efab4f9ccd5c64c4dfc6985e2345232890bad253f902d2e9ddadc0 +Independent family and order coverage audit: passed. A separate generator +checked all 216 families and all 3,674,160 raw orders. It produced the +identical 314,666-record binary input stream without reversal. See +independent-audit/CLEAN-ZERO-ORDER-RESULT.json. + +Complete coordinate-plus-one-basis case +--------------------------------------- +Fix the coordinate basis I. Let B be any binary basis of F_2^4. Allow +all eight-call words, with repetitions, over the union of their rank-one +basis projectors. The 840 unordered choices of B give 166 classes under +permutations of the three active coordinates. All 166 were checked. +Fixing one basis to I is a restriction of this class. It is not a valid +normalization of two arbitrary bases for the required active target. + + Scalar words checked: 7,406,643 + Relation states: 181,099,930 + Active monomial terminals: 262,735 + Terminals without a rank obstruction: 0 + +The generator uses actual commutation and the fourteen active distance +conditions. It uses no reversal or inverse symmetry. A second agent +independently reconstructed the basis catalogue, reviewed the driver and +collision rules, and checked the totals. A separate Fraction engine +agreed on 48 selected nonsymmetric and repeated-factor words. The full +7,406,643-word search was not repeated with a second arithmetic engine. +The two-basis engine reuses the clean F_101 relation core. Its result is +therefore not an independent full replay of the earlier H/I special case. + +Evidence: ../doubling-architecture/clean-ancilla/RESULT.txt and +ALL-BASIS-SUMMARY.json, plus ../doubling-architecture/rank-independent/ +clean-audit/PROOF-AUDIT.txt and ALL-ORDER-RESULT-AUDIT.json. + +Remaining work and cost implications +------------------------------------ +Any remaining candidate in this model must have frame span five or six, +must have a nonzero active off-pattern, and must use an alphabet outside +the coordinate-plus-one-basis class. Arbitrary scalar words with those +properties have not been excluded. More clean registers, more general +endpoint contracts, and non-abelian suppliers are outside this checkpoint. +The separately proved returned-register obstruction cannot be applied to +the clean endpoint: it has stricter conditions on the extra row and column. + +Even a future exact eight-call word would still need an all-size compiler. +That proof must normalize the three target frames, define the recursive +mixed active/temporary interface, and charge initialization, copies, +readout, erasure, address operations, and finite base cases. Existing +copy-transform-read-discard primitives support temporary workspace, but +do not by themselves compile every such algebraic word. The complex +supplier and the full outer construction must also meet the cost bound. + +Conditionally, eight child calls of volume V/3 for three active payloads +would give the ideal moment 8*3^(a-1)<3, or + + a < log(9/8)/log(3) = approximately 0.10721. + +This is a conditional supplier margin. It is not a proved global kappa, +and it does not establish the requested 1/256 milestone or 0.01 target. diff --git a/research/bit-clean-extra-register/sources/four-register/dirty_ancilla.py b/research/bit-clean-extra-register/sources/four-register/dirty_ancilla.py new file mode 100644 index 0000000000..2cc796fe7c --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/dirty_ancilla.py @@ -0,0 +1,169 @@ +"""Check two exact eleven-factor words from three binary basis layers.""" +from fractions import Fraction +from functools import lru_cache +from itertools import combinations +import json,time,sys +from pathlib import Path + +W=4; E=8; MAXREL=3 +ID=sum(1<<(i*W+i) for i in range(W)) +OFF=sum(1<<(i*W+j) for i in range(W) for j in range(W) if i!=j) +BITS=[tuple((s>>i)&1 for i in range(E)) for s in range(1<>i)&1)*((y>>j)&1)<<(W*i+j) for i in range(W) for j in range(W)) + +def times_projection(m,x,y): + mx=sum((((m>>(W*i))&15)&x).bit_count()%2<>bit)&1)<>bit&1] + seen=set();stats={'nodes':0,'terminals':0,'low_rank_targets':0,'zero_frame_branches':0,'parity_branches':0,'terminal_relations':[],'wrong_zero_count':0} + found=[] + def rec(state): + stats['nodes']+=1 + if state in seen:return False + seen.add(state) + if gf2_rank(first_order+[primitive_parity(r) for r in state])>MAXREL: + stats['parity_branches']+=1;return False + grouped={} + for s,c in poly: + key=rep(state,BITS[s]);grouped[key]=grouped.get(key,0)^c + terms=[(a,c) for a,c in grouped.items() if c] + offending=[(a,c&OFF) for a,c in terms if c&OFF] + if not offending: + stats['terminals']+=1 + stats['terminal_relations'].append([[str(x) for x in r] for r in state]) + targets=[] + for i in range(W): + tt=[v for v,c in terms if c>>(W*i+i)&1] + assert len(tt)==1,(state,tt) + targets.append(tt[0]) + for ancilla in range(W): + nxt=state if not any(targets[ancilla]) else add(state,targets[ancilla]) + if nxt is None or len(nxt)>MAXREL:continue + if gf2_rank(first_order+[primitive_parity(r) for r in nxt])>MAXREL:continue + low=False + for i,t in enumerate(targets): + if i==ancilla:continue + if any(not any(rep(rref(nxt+(UNIT[a],UNIT[b])),t)) for a,b in combinations(range(E),2)): + low=True;break + if low: + stats['low_rank_targets']+=1;continue + found.append({'ancilla':ancilla,'relations':[[str(x) for x in r] for r in nxt],'targets':[[str(x) for x in rep(nxt,t)] for t in targets]}) + return True + return False + if len(state)>=MAXREL:return False + best=None + for bit in range(W*W): + if not OFF>>bit&1:continue + tt=[v for v,c in offending if c>>bit&1] + if tt and (best is None or len(tt)>i)&1)< +#include +#include +#include +#include +#include +#include +#include +#include +using namespace std; + +int product(int a, int b) { + int result=0; + for(int i=0;i<4;++i)for(int j=0;j<4;++j) { + int bit=0; + for(int k=0;k<4;++k)bit^=((a>>(4*i+k))&1)&((b>>(4*k+j))&1); + result|=bit<<(4*i+j); + } + return result; +} + +int outer(int x,int y) { + int result=0; + for(int i=0;i<4;++i)if((x>>i)&1)result|=y<<(4*i); + return result; +} + +int main(int argc,char**argv) { + try { + if(argc!=3)throw runtime_error("Need expected family metadata and binary words"); + vector matrices; + for(int i=0;i<3;++i) { + int e=1<> dependent; + for(int i=0;i<11;++i)for(int j=i+1;j<11;++j) + if(product(matrices[i],matrices[j])!=product(matrices[j],matrices[i]))dependent.emplace_back(i,j); + vector> choices; + for(int i=0;i<3;++i)for(int j=i;j<3;++j)choices.emplace_back(i,j); + ifstream metadata(argv[1]), binary(argv[2],ios::binary); + if(!metadata || !binary)throw runtime_error("Cannot open input"); + uint64_t raw=0,total=0,families=0; + for(auto a:choices)for(auto b:choices)for(auto c:choices) { + array counts{}; + int family=0; + for(auto pair:{a,b,c}) { + ++counts[3*family+pair.first];++counts[3*family+pair.second];++family; + } + counts[9]=counts[10]=1; + for(int n:counts) { int expected;metadata>>expected;if(!metadata || expected!=n)throw runtime_error("Family mismatch"); } + uint64_t expected_raw,expected_offset,expected_orders; + metadata>>expected_raw>>expected_offset>>expected_orders; + if(!metadata || expected_offset!=total)throw runtime_error("Offset mismatch"); + vector word; + for(int i=0;i<11;++i)for(int j=0;j minimum; + uint64_t family_raw=0; + do { + uint32_t packed=0; + for(int letter:word)packed=(packed<<4)|letter; + string signature; + for(auto [i,j]:dependent) { + unsigned char bits=0; + for(int letter:word)if(letter==i || letter==j)bits=(bits<<1)|(letter==j); + signature.push_back(char(bits)); + } + auto [it,fresh]=minimum.emplace(signature,packed); + if(!fresh && packedsecond)it->second=packed; + ++family_raw; + }while(next_permutation(word.begin(),word.end())); + if(family_raw!=expected_raw || minimum.size()!=expected_orders)throw runtime_error("Family order count mismatch"); + vector representatives; + for(auto &entry:minimum)representatives.push_back(entry.second); + sort(representatives.begin(),representatives.end()); + for(uint32_t representative:representatives) { + unsigned char record[16]; + if(!binary.read(reinterpret_cast(record),16))throw runtime_error("Binary input ended early"); + for(int i=0;i<8;++i) { + int letter=(representative>>(4*(7-i)))&15; + if(record[2*i]+256*record[2*i+1]!=matrices[letter])throw runtime_error("Binary word mismatch"); + } + } + raw+=family_raw;total+=minimum.size();++families; + } + int extra;if(metadata>>extra)throw runtime_error("Unused metadata"); + if(binary.peek()!=char_traits::eof())throw runtime_error("Unused binary words"); + cout<<"{\"status\":\"PASS_INDEPENDENT_CLEAN_ZERO_ORDER_COVERAGE\",\"families\":"<=3, D+m<=8-m<=5 contradicts this code bound. If m=2, each d_i +is at least one and D<=4. At least two counts are one. Both extra +vectors must contain those two coordinates, so their pair has weight +two, a contradiction. If m=1, each d_i>=2 and D<=6, hence d=(2,2,2) +and the extra vector is (1,1,1). If m=0, all d_i>=3 needs D>=9. + +Thus the word has exactly two calls from each three-choice active +family, one fixed U=(1,1,1,1)e_4^T, and one fixed V=e_4(1,1,1,1)^T. +No E_44 call or other helper-star direction fits the call budget. +There are binomial(4,2)^3=216 multisets. This analytical reduction +was found independently by the audit agent. The exact finite code +check in ../clean_zero_off_distance.py gives the same classification. + +Complete word and relation check +-------------------------------- +generate.py lists every order of all 216 multisets, modulo swaps of +adjacent factors whose scalar projectors commute. It uses actual +projector products. It makes no reversal reduction. The resulting +counts are 3,674,160 raw orders and 314,666 commuting normal forms. + +CLEAN-SPAN-FOUR.txt proves that paid-frame span at most four needs +at least nine calls for the compressed active-block contract. Hence +an eight-call solution has relation dimension at most three. Search +all required subset collisions up to that dimension. A nonzero +active off-diagonal term must merge with a partner in its entry. +If an active diagonal has multiple terms, at least one of its first +two terms must merge with another current term; branch on every such +partner. This branch rule includes the case where those first two +terms merge with each other. + +At a terminal, all three active entries are monomials. Reject zero +paid frames and any active target in the span of at most two paid +frames. These necessary tests exclude an invertible target. Only the +active block is constrained; all entries involving the helper remain +unrestricted. No returned-helper equation is imposed. + +Two exact engines check every retained word. One uses primitive +integer rows. One uses F101 with the bounded-minor rational-equivalence +argument in F101-ARITHMETIC.txt. Both use at most three original cube +difference relations. After deterministic branch ordering, every +cumulative count and every terminal word/count agrees: + + words: 314,666 + states by relation rank: + 314,666; 1,005,125; 1,024,411; 2,160,151 + monomial terminals: 20,430 on 17,799 word IDs + accepted spaces: 0 + +An earlier integer run used another complete branch order. It also +rejected every word and found the same terminal word IDs. Its terminal +space count differed because it stopped at different already-rejected +subspaces. The canonical run resolves that diagnostic difference. + +Therefore no eight-call solution exists in this full zero-active-off- +pattern case. This is not yet an exclusion of all clean-helper words. +Together with CLEAN-ONE-RELATION.txt, after its analytic proof review, +it also excludes clean four-register words of frame span seven or +eight. General clean frame spans five and six remain unresolved here. diff --git a/research/bit-clean-extra-register/sources/four-register/independent/clean-zero/field.cpp b/research/bit-clean-extra-register/sources/four-register/independent/clean-zero/field.cpp new file mode 100644 index 0000000000..7048bc77e1 --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/independent/clean-zero/field.cpp @@ -0,0 +1,413 @@ +// Check four-register subset collisions with exact row reduction over F101. +// This file is derived from the PR468 field engine. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using Row = std::array; + +int prod[101][101], inverse[101], num[101], den[101], outer_table[16][16]; +constexpr int ID = 33825; +const int OFF_BITS[6] = {1,2,4,6,8,9}; + +int minus_product(int a, int t, int b) { + int q = a - prod[t][b]; + return q < 0 ? q + 101 : q; +} + +struct Basis { + std::array a{}; + std::array p{}; + int n = 0; + + bool operator==(const Basis& b) const { return a == b.a; } +}; + +struct BasisHash { + size_t operator()(const Basis& b) const { + size_t h = 0xcbf29ce484222325ULL; + for (const auto& r : b.a) + for (int x : r) + h = (h ^ x) * 0x100000001b3ULL; + return h; + } +}; + +Row subset(int m) { + Row v{}; + for (int i = 0; i < 8; ++i) + v[i] = (m >> i) & 1; + return v; +} + +Row residual(Row v, const Basis& b) { + for (int i = 0; i < b.n; ++i) { + int t = v[b.p[i]]; + if (t) + for (int j = b.p[i]; j < 8; ++j) + v[j] = minus_product(v[j], t, b.a[i][j]); + } + return v; +} + +Basis insert(Basis b, Row v) { + v = residual(v, b); + int p = 0; + while (p < 8 && !v[p]) + ++p; + if (p == 8) + return b; + if (b.n == 3) + throw std::logic_error("A state has too many relations"); + + int q = inverse[v[p]]; + for (int j = p; j < 8; ++j) + v[j] = prod[v[j]][q]; + for (int i = 0; i < b.n; ++i) { + int t = b.a[i][p]; + if (t) + for (int j = p; j < 8; ++j) + b.a[i][j] = minus_product(b.a[i][j], t, v[j]); + } + int at = b.n; + while (at && b.p[at - 1] > p) { + b.a[at] = b.a[at - 1]; + b.p[at] = b.p[at - 1]; + --at; + } + b.a[at] = v; + b.p[at] = p; + ++b.n; + return b; +} + +int binrank(const std::vector& rows) { + int b[8]{}, n = 0; + for (int v : rows) { + for (int k = 7; k >= 0; --k) { + if (!((v >> k) & 1)) + continue; + if (b[k]) { + v ^= b[k]; + } else { + b[k] = v; + ++n; + break; + } + } + } + return n; +} + +int primitive_parity(const Row& r) { + int d = 1; + for (int x : r) { + if (!den[x]) + throw std::logic_error("Rational reconstruction exceeds the proved bound"); + d = std::lcm(d, den[x]); + } + int v[8], g = 0; + for (int i = 0; i < 8; ++i) { + v[i] = num[r[i]] * (d / den[r[i]]); + g = std::gcd(g, std::abs(v[i])); + } + int bits = 0; + for (int i = 0; i < 8; ++i) + bits |= (std::abs(v[i] / g) & 1) << i; + return bits; +} + +struct GeneralBasis { + std::array a{}; + std::array p{}; + int n = 0; + + explicit GeneralBasis(const Basis& b) { + n = b.n; + for (int i = 0; i < n; ++i) { + a[i] = b.a[i]; + p[i] = b.p[i]; + } + } + + bool add(Row v) { + for (int i = 0; i < n; ++i) { + int t = v[p[i]]; + if (t) + for (int j = p[i]; j < 8; ++j) + v[j] = minus_product(v[j], t, a[i][j]); + } + int j = 0; + while (j < 8 && !v[j]) + ++j; + if (j == 8) + return false; + int q = inverse[v[j]]; + for (int k = j; k < 8; ++k) + v[k] = prod[v[k]][q]; + int at = n; + while (at && p[at - 1] > j) { + a[at] = a[at - 1]; + p[at] = p[at - 1]; + --at; + } + a[at] = v; + p[at] = j; + ++n; + return true; + } +}; + +bool target_small(int mask, const Basis& b) { + if (__builtin_popcount(static_cast(mask)) <= 2) + return true; + for (int i = 0; i < 8; ++i) { + for (int j = i + 1; j < 8; ++j) { + GeneralBasis g(b); + g.add(subset(1 << i)); + g.add(subset(1 << j)); + if (!g.add(subset(mask))) + return true; + } + } + return false; +} + +struct Group { + uint64_t key; + int mask, coefficient; +}; + +struct Search { + std::array word; + int ancillas = 15; + uint64_t index = 0; + std::array diagonal{}; + std::vector> terms; + std::vector off; + std::unordered_set visited; + uint64_t states[4]{}, parity = 0, zero = 0, terminals = 0; + uint64_t robust = 0, not_monomial = 0; + + void start() { + int coefficients[256]{}; + coefficients[0] = ID; + for (int j = 0; j < 8; ++j) { + int x = 0, y = 0; + for (int i = 0; i < 4; ++i) { + int row = (word[j] >> (4*i)) & 15; + if (row) { + if (y && y != row) throw std::logic_error("A projector has rank greater than one"); + y = row; x |= 1 << i; + } + } + if (!x || !y || !(__builtin_parity(unsigned(x&y)))) + throw std::logic_error("A projector is not a nonzero rank-one idempotent"); + for (int m = 0; m < (1 << j); ++m) { + int c = coefficients[m], u = 0; + for (int i = 0; i < 4; ++i) + u |= __builtin_parity(unsigned(((c >> (4*i)) & 15) & x)) << i; + int right = outer_table[u][y]; + coefficients[m] = c ^ right; + coefficients[m | (1 << j)] = right; + } + } + for (int m = 0; m < 256; ++m) + if (coefficients[m]) + terms.emplace_back(m, coefficients[m]); + for (int bit : OFF_BITS) { + int v = 0; + for (int j = 0; j < 8; ++j) + v |= ((word[j] >> bit) & 1) << j; + off.push_back(v); + } + for (int w = 0; w < 4; ++w) + for (int j = 0; j < 8; ++j) + diagonal[w] |= ((word[j] >> (5*w)) & 1) << j; + go(Basis{}); + } + + int allowed(const Basis& b) const { + auto ps = off; + for (int i = 0; i < b.n; ++i) ps.push_back(primitive_parity(b.a[i])); + return binrank(ps) <= 3; + } + + bool nonzero_frames(const Basis& b) const { + for (int i = 0; i < b.n; ++i) { + int count = 0; + for (int v : b.a[i]) count += v != 0; + if (count == 1) return false; + } + return true; + } + + void go(const Basis& b) { + if (!visited.insert(b).second) + return; + ++states[b.n]; + int possible = allowed(b); + if (!possible) { ++parity; return; } + if (!nonzero_frames(b)) { ++zero; return; } + + std::unordered_map positions; + std::vector groups; + positions.reserve(terms.size()); + groups.reserve(terms.size()); + for (auto [mask, c] : terms) { + auto v = residual(subset(mask), b); + uint64_t key = 0; + for (int j = 0; j < 8; ++j) + key |= uint64_t(v[j]) << (7 * j); + auto [it, fresh] = positions.emplace(key, int(groups.size())); + if (fresh) + groups.push_back({key, mask, c}); + else + groups[it->second].coefficient ^= c; + } + + std::vector active; + int counts[16]{}; + for (auto g : groups) { + if (g.coefficient) { + active.push_back(g); + for (int bit : OFF_BITS) + counts[bit] += (g.coefficient >> bit) & 1; + } + } + int chosen = -1; + for (int bit : OFF_BITS) + if (counts[bit] && (chosen < 0 || counts[bit] < counts[chosen])) + chosen = bit; + + if (chosen < 0) { + int target[3] = {-1,-1,-1}; + std::vector need; + for (int w=0; w<3; ++w) { + std::vector diagonal_terms; + for (auto g:active) if ((g.coefficient >> (5*w)) & 1) diagonal_terms.push_back(g); + if (diagonal_terms.empty()) throw std::logic_error("An active diagonal has zero augmentation"); + if (diagonal_terms.size()==1) target[w]=diagonal_terms[0].mask; + else if (need.empty() || diagonal_terms.size()>k)&1)-((need[j].mask>>k)&1); + v[k]=t<0?100:t; + } + auto c=insert(b,v); + if (c.n!=b.n+1) throw std::logic_error("A diagonal partner is in the same group"); + go(c); + } + return; + } + ++terminals; + for (int w=0;w<3;++w) if (target_small(target[w],b)) return; + ++robust; + std::cerr << "ROBUST " << index << " word"; + for (int n:word) std::cerr << ' ' << n; + std::cerr << " targets"; + for(int t:target)std::cerr << ' ' << t; + std::cerr << " relations"; + for(int i=0;i> chosen) & 1)) + ++first; + for (int j = first + 1; j < int(active.size()); ++j) { + if ((active[j].coefficient >> chosen) & 1) { + Row v{}; + for (int k = 0; k < 8; ++k) { + int t = ((active[first].mask >> k) & 1) - + ((active[j].mask >> k) & 1); + v[k] = t < 0 ? 100 : t; + } + auto c = insert(b, v); + if (c.n != b.n + 1) + throw std::logic_error("A partner is already in the same group"); + go(c); + } + } + } +}; + +void setup() { + for (int a = 0; a < 101; ++a) + for (int b = 0; b < 101; ++b) + prod[a][b] = (a * b) % 101; + for (int a = 1; a < 101; ++a) + for (int b = 1; b < 101; ++b) + if (prod[a][b] == 1) + inverse[a] = b; + for (int d = 1; d <= 5; ++d) { + for (int n = -5; n <= 5; ++n) { + if (std::gcd(std::abs(n), d) == 1) { + int x = prod[(n + 101) % 101][inverse[d]]; + if (den[x] && (num[x] != n || den[x] != d)) + throw std::logic_error("Rational reconstruction is not unique"); + num[x] = n; + den[x] = d; + } + } + } + for (int x = 0; x < 16; ++x) + for (int y = 0; y < 16; ++y) + for (int i = 0; i < 4; ++i) + if ((x >> i) & 1) outer_table[x][y] |= y << (4*i); +} + + +int main(int argc,char**argv) { + try { + if(argc!=3)throw std::runtime_error("Usage: clean_field INPUT OUTPUT"); + setup(); + std::ifstream input(argv[1],std::ios::binary); + if(!input)throw std::runtime_error("Cannot open input"); + input.seekg(0,std::ios::end);auto bytes=input.tellg(); + if(bytes<0 || bytes%16)throw std::runtime_error("Invalid input length"); + input.seekg(0); + uint64_t count=uint64_t(bytes)/16,states[4]{},terminals=0,robust=0,parity=0,zero=0; + std::ofstream out(argv[2]), terminal_output(std::string(argv[2])+".terminals.jsonl"); + if(!out || !terminal_output)throw std::runtime_error("Cannot open output"); + for(uint64_t index=0;index(data),16))throw std::runtime_error("Incomplete record"); + Search search;search.index=index; + for(int j=0;j<8;++j)search.word[j]=data[2*j]+256*data[2*j+1]; + search.start(); + for(int k=0;k<4;++k)states[k]+=search.states[k]; + terminals+=search.terminals;robust+=search.robust;parity+=search.parity;zero+=search.zero; + if(search.terminals || search.robust)terminal_output<<"{\"word\":"<>i&1) + +families=[[(1<j:blocked=True;break + if blocked:continue + counts[j]-=1 + yield from orders(counts,word+(j,)) + counts[j]+=1 + +start=time.time();records=[];offset=0;path=ROOT/'words.bin' +with path.open('wb') as out: + for pieces in product(list(combinations_with_replacement(range(3),2)),repeat=3): + counts=[0]*11 + for i,piece in enumerate(pieces): + for j in piece:counts[3*i+j]+=1 + counts[9]=counts[10]=1 + raw=math.factorial(8)//math.prod(math.factorial(c) for c in counts) + count=0 + for word in orders(counts): + out.write(struct.pack('<8H',*(matrices[j] for j in word))) + count+=1 + records.append({'family':len(records),'counts':counts[:],'raw_orders':raw,'offset':offset,'orders':count}) + offset+=count +result={'families':len(records),'projectors':projectors,'matrices':matrices,'raw_orders':sum(r['raw_orders'] for r in records),'commutation_orders':offset,'bytes':path.stat().st_size,'sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'seconds':time.time()-start,'records':records} +(ROOT/'catalogue.json').write_text(json.dumps(result,indent=2)+'\n') +print(json.dumps({k:v for k,v in result.items() if k!='records'})) diff --git a/research/bit-clean-extra-register/sources/four-register/independent/clean-zero/integer.cpp b/research/bit-clean-extra-register/sources/four-register/independent/clean-zero/integer.cpp new file mode 100644 index 0000000000..dc573410da --- /dev/null +++ b/research/bit-clean-extra-register/sources/four-register/independent/clean-zero/integer.cpp @@ -0,0 +1,373 @@ +// Adapt the PR468 integer relation engine to three active targets and one dirty helper. +// Read ordered words; use exact primitive integer rows for all rational relations. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using V = std::array; + +// Use a primitive integer row with a positive leading entry. +void normalize(V& v) { + int64_t divisor = 0; + for (int64_t x : v) divisor = std::gcd(divisor, std::abs(x)); + if (!divisor) return; + int leading = 0; + while (!v[leading]) ++leading; + if (v[leading] < 0) divisor = -divisor; + for (int64_t& x : v) x /= divisor; +} + +int pivot(const V& v) { + for (int i = 0; i < 8; ++i) { + if (v[i]) return i; + } + return 8; +} + +struct Rows { + std::array rows{}; + int size = 0; + bool operator==(const Rows& other) const { return rows == other.rows; } +}; + +struct HashRows { + size_t operator()(const Rows& basis) const { + size_t hash = 0; + for (const auto& row : basis.rows) { + for (int64_t x : row) hash = (hash ^ size_t(x + 97)) * 1099511628211ull; + } + return hash; + } +}; + +V reduce(V v, const Rows& basis) { + for (int a = 0; a < basis.size; ++a) { + const V& row = basis.rows[a]; + int p = pivot(row); + int64_t coefficient = v[p]; + if (coefficient) { + for (int i = 0; i < 8; ++i) { + v[i] = row[p] * v[i] - coefficient * row[i]; + } + normalize(v); + } + } + return v; +} + +Rows append(Rows basis, V v) { + v = reduce(v, basis); + if (pivot(v) == 8) return basis; + normalize(v); + int p = pivot(v); + for (int a = 0; a < basis.size; ++a) { + int64_t coefficient = basis.rows[a][p]; + if (coefficient) { + for (int i = 0; i < 8; ++i) { + basis.rows[a][i] = v[p] * basis.rows[a][i] - coefficient * v[i]; + } + normalize(basis.rows[a]); + } + } + basis.rows[basis.size++] = v; + std::sort(basis.rows.begin(), basis.rows.begin() + basis.size, + [](const V& a, const V& b) { return pivot(a) < pivot(b); }); + return basis; +} + +V vec(int mask) { + V v{}; + for (int i = 0; i < 8; ++i) v[i] = (mask >> i) & 1; + return v; +} + +int binaryrank(std::vector rows) { + int basis[8]{}, rank = 0; + for (int v : rows) { + for (int i = 7; i >= 0; --i) { + if (!(v >> i & 1)) continue; + if (basis[i]) { + v ^= basis[i]; + } else { + basis[i] = v; + ++rank; + break; + } + } + } + return rank; +} + +// Binary 4 by 4 matrices use row-major bit order. +constexpr int ID = 0x8421; +constexpr int OFF = 0x356; +constexpr int OFFBITS[6] = {1,2,4,6,8,9}; + +int outer(int x, int y) { + int m = 0; + for (int i = 0; i < 4; ++i) if (x >> i & 1) m |= y << (4*i); + return m; +} + +std::pair decode(int m) { + int x = 0, y = 0; + for (int i = 0; i < 4; ++i) { + int row = (m >> (4*i)) & 15; + if (row) { + if (y && y != row) throw std::runtime_error("Projector rank is not one"); + y = row; + x |= 1 << i; + } + } + if (!x || !y || !(__builtin_parity(x & y))) { + throw std::runtime_error("Invalid rank-one projector"); + } + return {x,y}; +} + +int times_projection(int m, int x, int y) { + int mx = 0; + for (int i = 0; i < 4; ++i) mx |= __builtin_parity(((m >> (4*i)) & 15) & x) << i; + return outer(mx,y); +} + +struct KeyHash { + size_t operator()(const V& v) const { + size_t hash = 0; + for (int64_t x : v) hash = (hash ^ size_t(x + 4097)) * 1099511628211ull; + return hash; + } +}; + +struct Group { + V key; + int mask, matrix; +}; + +struct Solver { + std::array ns; + int ancilla_mask = 0; + std::vector> terms; + std::vector offrows; + std::unordered_set seen; + uint64_t states[4]{}, parityprune = 0, zeroprune = 0, terminal = 0, robust = 0; + std::ofstream* cert = nullptr; + int wordidx = 0; + + void init() { + terms = {{0, ID}}; + for (int j = 0; j < 8; ++j) { + auto [x,y] = decode(ns[j]); + std::vector> next; + for (auto [mask, matrix] : terms) { + int variable = times_projection(matrix, x, y); + int constant = matrix ^ variable; + if (constant) next.emplace_back(mask, constant); + if (variable) next.emplace_back(mask | (1 << j), variable); + } + terms = next; + } + std::sort(terms.begin(), terms.end()); + for (int bit : OFFBITS) { + int row = 0; + for (int i = 0; i < 8; ++i) row |= ((ns[i] >> bit) & 1) << i; + offrows.push_back(row); + } + } + + // Check whether a target is a linear combination of at most two physical frames. + bool target_rank_small(int mask, const Rows& relations) { + for (int i = 0; i < 8; ++i) { + for (int j = i + 1; j < 8; ++j) { + std::vector basis(relations.rows.begin(), + relations.rows.begin() + relations.size); + auto add = [&](V v) { + for (const auto& row : basis) { + int p = pivot(row); + int64_t coefficient = v[p]; + if (coefficient) { + for (int k = 0; k < 8; ++k) { + v[k] = row[p] * v[k] - coefficient * row[k]; + } + normalize(v); + } + } + if (pivot(v) < 8) { + normalize(v); + basis.push_back(v); + std::sort(basis.begin(), basis.end(), + [](const V& a, const V& b) { return pivot(a) < pivot(b); }); + } + }; + add(vec(1 << i)); + add(vec(1 << j)); + int before = basis.size(); + add(vec(mask)); + if (int(basis.size()) == before) return true; + } + } + return false; + } + + void go(const Rows& relations) { + if (!seen.insert(relations).second) return; + ++states[relations.size]; + + auto parity = offrows; + for (int a = 0; a < relations.size; ++a) { + int row = 0; + for (int j = 0; j < 8; ++j) { + row |= (std::abs(relations.rows[a][j]) & 1) << j; + } + parity.push_back(row); + } + if (binaryrank(parity) > 3) { + ++parityprune; + return; + } + for (int i = 0; i < 8; ++i) { + if (pivot(reduce(vec(1 << i), relations)) == 8) { + ++zeroprune; + return; + } + } + + // Form exact quotient keys with one common integer denominator. + int64_t denominator = 1; + for (int a = 0; a < relations.size; ++a) { + denominator = std::lcm(denominator, relations.rows[a][pivot(relations.rows[a])]); + } + std::unordered_map, KeyHash> groups; + for (auto [mask, matrix] : terms) { + V key = vec(mask); + for (int64_t& x : key) x *= denominator; + for (int a = 0; a < relations.size; ++a) { + int p = pivot(relations.rows[a]); + if (mask >> p & 1) { + for (int j = 0; j < 8; ++j) { + key[j] -= (denominator / relations.rows[a][p]) * relations.rows[a][j]; + } + } + } + auto [it, inserted] = groups.emplace(key, std::make_pair(mask, 0)); + it->second.second ^= matrix; + } + std::vector active; + bool has_offdiagonal = false; + for (const auto& [key, term] : groups) { + if (term.second) { + active.push_back({key, term.first, term.second}); + has_offdiagonal |= (term.second & OFF) != 0; + } + } + + + std::sort(active.begin(), active.end(), [](const Group& a, const Group& b) { return a.mask < b.mask; }); + if (!has_offdiagonal) { + int targets[3] = {-1,-1,-1}; + std::vector needed; + for (int w=0;w<3;++w) { + std::vector present; + for (const auto& group:active) if(group.matrix>>(5*w)&1)present.push_back(group); + if(present.empty())throw std::logic_error("An active diagonal has zero augmentation"); + if(present.size()==1)targets[w]=present[0].mask; + else if(needed.empty() || present.size()>k)&1)-((needed[j].mask>>k)&1); + Rows next=append(relations,difference); + if(next.size!=relations.size+1)throw std::logic_error("A diagonal partner is in the same group"); + go(next); + } + return; + } + ++terminal; + for(int w=0;w<3;++w)if(target_rank_small(targets[w],relations))return; + ++robust; + if(cert) { + *cert<> bit) & 1; + if (count && count < best_count) { best_bit = bit; best_count = count; } + } + for (int a = 0; a < int(active.size()); ++a) { + if (active[a].matrix >> best_bit & 1) { best = a; break; } + } + for (int b = 0; b < int(active.size()); ++b) { + if (b != best && (active[b].matrix >> best_bit & 1)) { + V difference{}; + for (int i = 0; i < 8; ++i) { + difference[i] = ((active[best].mask >> i) & 1) - ((active[b].mask >> i) & 1); + } + Rows next = append(relations, difference); + if (next.size == relations.size) { + throw std::logic_error("Partner already in this group"); + } + go(next); + } + } + } +}; + + +int main(int argc,char**argv) { + try { + if(argc!=3)throw std::runtime_error("Usage: clean_integer INPUT OUTPUT"); + std::ifstream input(argv[1],std::ios::binary); + if(!input)throw std::runtime_error("Cannot open input"); + input.seekg(0,std::ios::end);auto bytes=input.tellg(); + if(bytes<0 || bytes%16)throw std::runtime_error("Invalid input length"); + input.seekg(0); + uint64_t count=uint64_t(bytes)/16,states[4]{},terminals=0,robust=0,parity=0,zero=0; + std::ofstream out(argv[2]), terminal_output(std::string(argv[2])+".terminals.jsonl"), candidates(std::string(argv[2])+".candidates.txt"); + if(!out || !terminal_output || !candidates)throw std::runtime_error("Cannot open output"); + for(uint64_t index=0;index(data),16))throw std::runtime_error("Incomplete record"); + Solver solver;solver.wordidx=index;solver.cert=&candidates; + for(int j=0;j<8;++j)solver.ns[j]=data[2*j]+256*data[2*j+1]; + solver.init();solver.go(Rows{}); + for(int k=0;k<4;++k)states[k]+=solver.states[k]; + terminals+=solver.terminal;robust+=solver.robust;parity+=solver.parityprune;zero+=solver.zeroprune; + if(solver.terminal || solver.robust)terminal_output<<"{\"word\":"<> i) & 1) << p[i] for i in range(4)) + def canonical(basis): + return min(tuple(sorted((permute(x, p + (3,)), + permute(y, p + (3,))) for x, y in basis)) + for p in itertools.permutations(range(3))) + orbits = Counter(canonical(basis) for basis in bases) + rows = [list(map(int, line.split())) for line in path.read_text().splitlines()] + require(all(len(row) == 16 for row in rows), "Invalid alphabet row") + alphabets = [tuple(zip(row[::2], row[1::2])) for row in rows] + identity = tuple((1 << i, 1 << i) for i in range(4)) + require(len(bases) == 840 and len(orbits) == 166, "Basis count") + require(all(row[:4] == identity for row in alphabets), "Coordinate basis") + require(len(alphabets) == 166 and + set(row[4:] for row in alphabets) == set(orbits), "Basis coverage") + require(Counter(orbits.values()) == {1: 6, 3: 42, 6: 118}, "Orbit sizes") + return {"unordered_bases": 840, "alphabets": 166, + "orbit_sizes": dict(Counter(orbits.values()))} + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--build", type=Path, required=True) + args = parser.parse_args() + build = args.build.resolve() + require(not build.exists(), "The build directory exists.") + manifest = read(ROOT / "SOURCE-MANIFEST.json") + for item in manifest["files"]: + require(hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() + == item["sha256"], "Source hash: " + item["package"]) + build.mkdir(parents=True) + shutil.copytree(ROOT / "sources", build / "sources") + clean = build / "sources/four-register/independent/clean-zero" + audit = build / "sources/four-register/independent-audit" + basis = build / "sources/doubling-architecture/clean-ancilla" + selected = build / "sources/doubling-architecture/rank-independent/clean-audit" + compiler = os.environ.get("CXX") or shutil.which("clang++") or shutil.which("g++") + require(compiler is not None, "A C++17 compiler is required.") + for source, target in [(clean / "integer.cpp", clean / "integer"), + (clean / "field.cpp", clean / "field"), + (audit / "check_clean_zero_orders.cpp", audit / "orders"), + (basis / "two_bases.cpp", basis / "two_bases"), + (selected / "selected_words.cpp", selected / "selected_words")]: + run([compiler, "-O3", "-std=c++17", source, "-o", target], + build / (target.name + "-compile.log")) + run([sys.executable, "-E", "-B", clean / "generate.py"], build / "clean-generate.log") + expected = read(ROOT / "expected/clean-zero-result.json") + require(hashlib.sha256((clean / "words.bin").read_bytes()).hexdigest() + == expected["word_sha256"], "Clean word stream") + run([audit / "orders", audit / "clean-zero-family-metadata.txt", clean / "words.bin"], + build / "independent-orders.json") + independent = read(build / "independent-orders.json") + require(independent == expected["independent_front_end_audit"], "Independent orders") + for engine in ["integer", "field"]: + run([clean / engine, clean / "words.bin", clean / (engine + ".jsonl")], + build / (engine + "-run.log")) + for suffix in [".jsonl", ".jsonl.terminals.jsonl"]: + require((clean / ("integer" + suffix)).read_bytes() == + (clean / ("field" + suffix)).read_bytes(), "Engine comparison: " + suffix) + totals = json.loads((clean / "integer.jsonl").read_text().splitlines()[-1]) + require(totals == expected["engine_totals"], "Clean totals") + require(len((clean / "integer.jsonl.terminals.jsonl").read_text().splitlines()) + == expected["terminal_word_count"], "Terminal word count") + catalogue = check_alphabets(basis / "ALPHABETS.txt") + results = [] + for index in range(166): + output = build / f"basis-{index:03d}.json" + run([basis / "two_bases", basis / "ALPHABETS.txt", index, output], + build / f"basis-{index:03d}.log") + results.append(read(output)) + full = {"alphabets": 166, "completed": len(results), "results": results, + "states": [sum(row["states"][i] for row in results) for i in range(4)]} + for key in ["searched_words", "terminals", "robust"]: + full[key] = sum(row[key] for row in results) + (build / "all-basis-summary.json").write_text(json.dumps(full, indent=2) + "\n") + old = read(ROOT / "expected/all-basis-summary.json") + require(full["completed"] == full["alphabets"] == 166, "Incomplete basis run") + for key in ["searched_words", "states", "terminals", "robust"]: + require(full[key] == old[key], "Basis total: " + key) + for actual, expected_row in zip(full["results"], old["results"]): + require(actual["complete"] and actual["robust"] == 0, "Incomplete alphabet") + for key in expected_row: + if key != "seconds": + require(actual[key] == expected_row[key], "Alphabet field: " + key) + fixed = read(ROOT / "expected/selected-comparison.json")["results"] + words = [row["word"] for row in fixed] + encoded = "".join(" ".join(str(n) for xy in word for n in xy) + "\n" for word in words) + output = subprocess.run([str(selected / "selected_words")], input=encoded, + text=True, capture_output=True, check=True) + field = [json.loads(line) for line in output.stdout.splitlines()] + require(len(field) == len(words) == 48, "Selected word count") + spec = importlib.util.spec_from_file_location("clean_search", basis / "search.py") + exact = importlib.util.module_from_spec(spec) + spec.loader.exec_module(exact) + checks = [] + for i, word in enumerate(words): + rational = exact.solve(word) + require(len(rational["found"]) == field[i]["robust"] == 0, "Selected survivor") + require(rational["stats"]["terminals"] == field[i]["terminals"], "Selected terminals") + checks.append({"case": i, "word": word, "rational": rational["stats"], "field": field[i]}) + exact.d.rref.cache_clear() + exact.d.rep.cache_clear() + exact.d.add.cache_clear() + (build / "selected-comparison.json").write_text(json.dumps(checks, indent=2) + "\n") + receipt = {"status": "PASS_CLEAN_RESTRICTED_CLASSES", "clean_zero": totals, + "independent_orders": independent, "basis_catalogue": catalogue, + "all_basis": {key: full[key] for key in + ["alphabets", "completed", "searched_words", "states", "terminals", "robust"]}, + "selected_rational_field_words": len(checks), + "source_manifest_sha256": hashlib.sha256((ROOT / "SOURCE-MANIFEST.json").read_bytes()).hexdigest(), + "scope": "Restricted clean endpoint; frame spans five and six remain open."} + (build / "receipt.json").write_text(json.dumps(receipt, indent=2) + "\n") + print(receipt["status"], totals["words"], full["searched_words"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/bit-three-active-one-returned/AUDIT.txt b/research/bit-three-active-one-returned/AUDIT.txt new file mode 100644 index 0000000000..2e32dd87a3 --- /dev/null +++ b/research/bit-three-active-one-returned/AUDIT.txt @@ -0,0 +1,323 @@ +Three active targets and one returned register: independent audit + +Model and relation bound + +The exact target is diag([C1],[C2],[C3],1), up to a permutation of +coordinates. The C_i are invertible lower-triangular rational 3-by-3 +frames. The fourth input is arbitrary and must be returned unchanged. +The paid frames are nonzero rational rank-one matrices. There are eight +binary rank-one idempotent scalar calls. + +The span-four lemma continues to hold with zero targets: replace the +number of scalar registers in each projected target-rank count by the +number of active targets. Choose an active invertible target when the +proof forms target ratios. Zero targets stay zero in each block; active +targets have invertible diagonal blocks. Thus frame span at most four +requires at least nine calls. Any eight-call circuit needs frame span +at least five and rational relation dimension at most three. + +A candidate must be scalar irreducible. Let V be a common binary invariant subspace. The product preserves +V after extension to the group algebra. Distinct group monomials are +linearly independent. Thus each coordinate projection onto one equal- +character space preserves V. This includes the zero character of the +returned register, which differs from every active target character. +V is the direct sum of its intersections with those character spaces. +Choose a basis in each equal-character space adapted to V. This keeps +the endpoint diagonal and puts every paid scalar projector in block +upper-triangular form. This argument does not assume that V is a +coordinate subspace or that the three active characters are distinct. +A rank-one idempotent in this block form has exactly one nonzero +diagonal block, and that block is a rank-one idempotent. Thus the calls +partition between the two diagonal blocks. A block with one active +target needs at least three calls by rank subadditivity. Two active +targets need at least six, even with returned coordinates: at at most +five calls, span at most four is covered by the preceding lemma; the +only other case has five independent frames. No distinct subset sums +then collide, and differentiation of the diagonal polynomial at one +forces all scalar projectors to be coordinate projectors. Each active +target still needs three frames. A proper block with all three active +targets has size three and is covered by PR468. Every split therefore +needs at least nine calls. These arguments are also in DIRTY-MODEL.txt +and were reviewed separately by bit8_algebra and the root agent. + +Visible scalar distance is a rational-rank argument + +Fix a possible returned coordinate a. For a binary row v, let J be +the calls with v*x_j=1. If a rational functional kills all frames in +J, each projected factor fixes v. The projected target can fix v only +if it kills each active target selected by v. Thus each such target is +in the rational span of the frames in J. Fewer than three rank-one +frames cannot span an invertible 3-by-3 target. Every nonzero v other +than e_a must therefore select at least three calls. The argument for +y_j and columns is the dual statement. It uses no reduction of address +frames modulo two. + +The code correctly takes the union over all four possible returned +roles. A row or column of weight greater than one with fewer than three +visible calls rejects every role. A failing singleton leaves only its +own role. Two different failing singletons reject every role. + +The exact returned-register condition + +At a rational diagonal terminal, every diagonal entry is one monomial, +by the determinant/unit argument in PROOF-AUDIT.txt. A returned entry +must equal [0]=1 in the group algebra of rational frames. This requires +its exponent to be exactly zero, not merely even or zero modulo two. + +dirty_ancilla.py implements this correctly: for each possible returned +coordinate, it adds that exponent as an exact rational relation using +Fraction RREF. It rejects zero paid frames and relation rank above +three. It then checks every active target against the exact rational +span of each pair of paid-frame units. This test does not use a short +representative in a binary quotient. Each rejected active target is +therefore a rational sum of at most two rank-one matrices. + +Adding a relation after reaching a diagonal terminal cannot create an +off-diagonal term. There is no missing collision branch at this step. +Trying every coordinate covers every possible returned role. + +The finite binary quotient is only a necessary identity check + +Let K be the actual saturated integer relation lattice in Z^8. Its +modulo-two image has dimension at most three. The off-diagonal +augmentation derivative rows belong to this image. The returned +diagonal derivative row belongs to it too, since the derivative of 1 +is zero. The active diagonal rows need not belong to it. + +If the selected derivative rows have rank greater than three, the +candidate is impossible. If their rank is exactly three, their span +is the full modulo-two image of K. Map the formal polynomial to the +finite group algebra of F2^8 modulo that span. Every off-diagonal +entry must still vanish. If the returned diagonal is included, it must +equal one, and the code subtracts that constant before checking it. + +The H-alphabet filter uses only off-diagonal rows. The later rank-two +and generic rank-three filters also use a candidate returned diagonal. +When the selected rank is below three, the rank-two filter retains the +word because an additional unknown relation may still occur. It takes +the union of the results for all admissible returned coordinates. + +This check is sound because every valid rational identity maps to the +finite quotient identity. The converse is false. In particular, a short +binary representative of an active target does not imply a rational +rank bound. None of the inspected filters makes that false inference. + +Independent H-alphabet census + +The alphabet consists of four coordinate projectors and the four +projectors from H=I+J_4. An independent script enumerates multiplicities +as weak compositions, not as the producer's combinations with +replacement. It checks irreducibility by closing the orbit span of each +nonzero vector, instead of enumerating invariant subspaces. + +It groups orders by their subsequences on every pair of noncommuting +letters. These dependence signatures identify trace classes. An +independent explicit orbit calculation then applies coordinate +permutations and reversal. This does not reuse the producer's greedy +trace-normalization procedure to establish class coverage. + +For each class, direct dense matrix multiplication in the finite group +algebra checks the binary quotient condition. This differs from the +producer's formal polynomial expansion and remainder grouping. + +The complete independent census agrees: + + 20 distance-compatible multiplicity classes; + 14 scalar-irreducible classes; + 216720 distinct raw orders within those representative classes; + 2771 classes after the valid order symmetries; + 1115 words rejected by the binary quotient identity. + +The other 1656 representative words use the separately audited rational +collision solver. Its saved result has zero candidates. The finite +census does not claim an independent full rational collision replay. + +Reversal remains valid for nonsymmetric projectors + +For any idempotent N, D_N(z)^(-1)=D_N(z^(-1)). Invert a valid diagonal +word, then apply the address-group map A -> -A. This reverses factor +order and preserves the original diagonal target. Thus generic order +searches may use reversal without transposing the individual N_j. +Commuting adjacent factors is also valid for every assignment of frames. + +Independent coverage of the generic off-pattern catalogue + +There are 120 binary rank-one idempotents in four registers. Their +nonzero off-diagonal parts have 104 distinct patterns. The derivative +bound implies that the actual off-pattern span has dimension at most +three: the row rank and column rank of the derivative matrix agree. +Its basis can be chosen from the actual patterns. Thus direct spans of +all one-, two-, and three-element pattern subsets cover every case. + +Each catalogue pool contains every projector with pattern in its space, +including all four coordinate projectors. If that full pool is +reducible, every subset is reducible. A subspace invariant under all +coordinate projectors must be a coordinate subspace. Hence the full +pool is irreducible exactly when its union support graph is strongly +connected. It is valid to discard non-strong spaces. Individual +multisets in a strong pool still need their own irreducibility check. + +The independent generator uses direct pattern combinations, a compact +twelve-bit encoding, Boolean matrix transitive closure, and explicit +coordinate-permutation orbits. It reproduces every representative and +every complete projector pool in the producer's catalogue: + + rank one: 104 spaces, 0 strong spaces, 0 classes; + rank two: 4964 spaces, 634 strong spaces, 45 classes; + rank three:140281 spaces, 63567 strong spaces,2846 classes. + +The exact numbers of eight-call multisets over the full pools are +sum_pool binomial(pool_size+7,8): 61347 for rank two and 11210628 for +rank three. The catalogue receipt records independent canonical hashes. + +Review of the generic C++ multiset filter + +rank3_multisets.cpp enumerates every nonnegative count vector with sum +eight in each pool. It requires actual off-pattern rank three, applies +the visible-distance condition, and tries every possible returned role. +For each role it appends the actual N_aa bit to the off-pattern vector +and requires augmented binary rank at most three. All of these are +necessary conditions. Multiplicity does not change the column-span +rank, but the distance count correctly includes multiplicities. + +Its invariant-subspace check closes the orbit span of each nonzero +vector under the used projectors. A fixed proper orbit span is an +invariant subspace. If a proper invariant subspace exists, an orbit +started inside it cannot reach the whole space. The check is exact. + +The integer fields called off must be a linear coordinate map for the +catalogue's off-pattern space. The separate input-binding check verifies +all projector labels and all pairwise XOR identities for these labels. +The source review does not alone certify an arbitrary unbound input file. + +Independent generic multiset and order replays + +A second C++ census enumerates supports first and then positive +multiplicities. It computes binary rank from the full matrix bits and +checks all 65 proper nonzero binary subspaces directly. This differs +from the producer's count-vector recursion, compressed space labels, +and invariant orbit closures. It examines all 11210628 rank-three +pool multisets and returns exactly the same 4020 families and returned- +role masks. A separate binding script checks every pool and label, +every family count vector, every text order, and every binary record. + +A second C++ order check enumerates all 41706000 raw permutations with +next_permutation. It checks trace normality only after a full order is +formed. The producer instead removes non-normal prefixes. The second +check computes commutation by full matrix multiplication. It computes +the quotient by explicit span and complement sets, then uses one +32-bit group-ring vector for each scalar matrix entry. The producer +uses packed matrix coefficients indexed by quotient elements. + +The independent replay gives these exact counts: + + 4020 multiset families; + 41706000 raw orders; + 7121514 commutation normal forms; + 3560923 representatives after reversal; + 1901600 finite-quotient survivors. + +Every retained matrix word and returned-role mask agrees, in order, +with the shared binary input to both collision engines. That input has +34228800 bytes and SHA-256 +97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911. +The rank-three shared front end therefore has a complete independent +replay. + +The same support-first census independently checks all 61347 rank-two +pool multisets and returns the same 103 retained families. A separate +Python replay enumerates all 831600 raw orders by choosing positions +for each repeated letter. It groups them by their subsequences on +noncommuting letter pairs, then takes reversal orbits. Thus it does +not use the producer's greedy normal form or prefix pruning. It gets +54294 trace classes and 27156 reversal representatives. Every matrix +word and returned-role mask agrees with rank2-words.bin before any +finite-quotient pruning. That file has 488808 bytes and SHA-256 +f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee. + +Exact collision search + +At a state with rational relation space R, reduce the formal polynomial +modulo R. Choose a term in a nonzero off-diagonal entry. In any valid +extension of R, that term must collide with another surviving term in +the same entry. Branch on every such difference. Terms already removed +in pairs stay removed under every extension. Thus no necessary branch +is lost. Each new relation increases rank, and rank is at most three. +A diagonal terminal can add the exact returned exponent as a relation. +Adding this relation cannot create an off-diagonal entry. + +The determinant of each paid factor is its frame monomial. A diagonal +terminal therefore has monomial product determinant. The frame group +is finitely generated and torsion-free, so its group algebra is a +Laurent polynomial ring over F2. Its units are monomials. Each diagonal +entry is consequently a single monomial. The exact rational pair-span +test rejects a target in the span of two paid rank-one frames. This is +a necessary rank-three condition, not a sufficient construction test. + +Two engines complete the rank-three input: the primitive-integer +engine and the finite-field engine with exact rational reconstruction. +Both process all 1901600 words, return the same 538 terminal word IDs, +and have zero surviving target candidates. A Fraction implementation +also replays all 538 terminal words and rejects all of them. The rank- +two primitive-integer run processes all 27156 canonical words before +any finite-quotient pruning, and has zero diagonal terminals. + +Why reduction modulo 101 is exact here + +Every state has at most three independent original relation rows. +Each original row is a difference of two subset indicators, or the +returned subset indicator. Its entries are in {-1,0,1}. A rank or +membership test adds at most one further such row. Pair-span tests +also append two coordinate unit rows; expansion along those rows +removes them from the relevant minors. Every remaining minor uses at +most four bounded nonunit rows. Hadamard's bound gives absolute value +at most 16, which is less than 101. A nonzero rational rank witness +therefore cannot vanish modulo 101. + +Each completed state RREF entry is a ratio of minors of order at most +three. Numerator and denominator have absolute value at most five. +Two such reduced fractions cannot have the same residue modulo 101: +their cross difference has absolute value at most 50. Thus the code's +bounded rational reconstruction is unique. The parity prune uses the +primitive integer lift of this rational row, and hence uses a member +of the actual saturated integer kernel. It does not assume that a +chosen set of nonprimitive integral generators is already saturated. + +Bounds for the primitive-integer implementation + +Completed primitive state rows have entries of absolute value at most +five, by the same minor bound. Their positive pivots are at most five. +A raw bounded row reduced against three such rows has intermediate +entries at most 1000. The separate pair-span helper can append two +unit rows: a conservative bound is 1000 for the first reduced row, +2000000 for the second, and 8000000000000 while reducing the target. +All are below the signed 64-bit limit. The common quotient denominator +is at most lcm(1,2,3,4,5)=60, and quotient-key entries are at most 960. +The reviewed arithmetic does not depend on signed overflow. + +Scope of completion + +The analytic reductions, the generic off-pattern catalogue, the full +rank-three multiset and order front end, and the exact collision tests +have passed independent mathematical review. The finite-field test +has an explicit rational-equivalence proof; it is not a probabilistic +prime test. The two final engines use different arithmetic but share +an input file, whose complete generation has a separate independent replay for both +rank two and rank three. Both the catalogue and the role union are +covered by these replays. + +Subject to the proved span-four and three-register lemmas in PR468, +the exact eight-call classification excludes three active invertible +lower-triangular rational 3-by-3 targets with one arbitrary returned +register. Any positive shorter word can be padded to eight calls by +splitting a nonzero rank-one frame A into two consecutive calls with +frame A/2 and the same projector. Hence eight-call impossibility also +excludes shorter words. Nine coordinate calls realize the three +identity 3-by-3 targets and return the fourth register. The minimum +number of calls in this specified model is therefore nine. + +This conclusion concerns four scalar registers, rank-one rational +paid frames, binary rank-one idempotent scalar projectors, and a +formal identity for all inputs. It is not a lower bound for every bit +construction in the repository. It gives no direct increase in kappa. +This audit is mathematical and computational; it is not a Lean proof. diff --git a/research/bit-three-active-one-returned/PROOF.txt b/research/bit-three-active-one-returned/PROOF.txt new file mode 100644 index 0000000000..d8fb4cec0e --- /dev/null +++ b/research/bit-three-active-one-returned/PROOF.txt @@ -0,0 +1,168 @@ +Three active targets with one returned register need nine calls +=============================================================== + +Theorem and model +----------------- +Work over F_2[G], where G is the additive group of rational 3 by 3 +matrices. Let [A] denote its group element. A paid factor is + + D_N([A]) = I + ([A]-1)N, + N = xy^T, x,y in F_2^4, y^T x = 1. + +Each paid frame A is nonzero and has rational matrix rank one. For +invertible lower-triangular rational C_1,C_2,C_3, an identity + + product_j D_(N_j)([A_j]) = diag([C_1],[C_2],[C_3],1) + +requires at least nine paid factors. Nine suffice. The fourth input +is arbitrary and must be returned exactly. This is a formal identity +in all address variables, not a check on selected input values. + +The finite part of this proof has two exact implementations. The +status of the independent proof audit is stated in AUDIT.txt. This +result does not give a positive bound improvement for integer +multiplication. It excludes one proposed small circuit. + +1. Reduction to eight calls and relation rank at most three +--------------------------------------------------------- +A factor can be split into two: D_N([A/2])^2 = D_N([A]). Thus every +nonempty word with fewer than eight calls can be padded to eight, +with nonzero rank-one frames. Zero calls cannot give an active target. + +Use the span-four lemma of the three-register lower-bound proof: +https://github.com/CrocSwap/integer-mult-bounds/pull/468 +The source used here is research/bit-three-register-lower-bound/README.md +at commit 07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea in the author's fork. +Its proof applies to any number of scalar registers and extends to +zero target frames: replace every target-minus-identity rank W by +the number of active targets. Choose an active target for the common +ratio flag argument. Zero targets remain zero under each projection. +The result is that rational paid-frame span at most four needs at +least three calls per active invertible lower-triangular target. + +For clarity, the span-four proof has two cases. Three independent +rank-one basis frames can be mapped to diagonal coordinate matrices. +The fourth is uv^T. If u and v have full support, every rank-one frame +is on one of four basis lines. Each invertible target needs at least +three lines, and line projection gives one call per active coefficient. +Otherwise the frame space has upper-triangular diagonal blocks of size +at most two. Rank-one calls have at most one nonzero diagonal block. +The target ratio flag descends to each block. A one-dimensional block +needs W active calls. For a two-dimensional block, project its upper +entry to zero. If U calls survive, the compact product formula gives +r_X+r_Y <= U. The two diagonal projections give W <= r_X+l_i and +W <= r_Y+l_i for i=0,1. Hence 2W <= U+l_0+l_1 <= E_2. The block bounds +sum to 3W. This argument uses the lower-triangular target hypothesis. + +An eight-call solution therefore has frame span at least five. Its +rational relation space in Q^8 has dimension at most three. + +2. Scalar irreducibility and distance +------------------------------------ +One active target needs at least three calls, even with returned +registers: its frame is in the span of the paid rank-one frames. +Two active targets need at least six. At five calls, frame span at +most four is covered above. At span five the frames are independent; +all subset monomials are distinct. Vanishing off-diagonal coefficients +and differentiation at one make every scalar projector diagonal. +The calls then divide between the targets, whose ranks sum to six. + +Suppose the projectors preserve a proper binary subspace. The diagonal +target preserves it as well. Its distinct monomial coefficients are +coordinate projections onto groups with equal target frames, including +the zero frame. These projections preserve the subspace. Choose bases +inside each group adapted to that subspace. The target stays diagonal. +Each rank-one idempotent acts nontrivially on exactly one diagonal +block. If both blocks have active targets, their counts are one and +two, so their disjoint call counts sum to at least nine. If all three +active targets are in one block, it has dimension three; PR468 applies +and again requires nine. Thus an eight-call solution is irreducible. + +For an allowed returned coordinate a, every nonzero binary row r other +than e_a must see at least three image vectors x_j, and at least three +row vectors y_j. Otherwise choose a rational functional that kills the +at most two frames seen by r and does not kill an active target in +its support. The projected circuit fixes r but the target does not. + +3. Finite scalar catalogue +------------------------- +Let L be the saturated kernel of Z^8 -> . Its reduction +modulo two has dimension at most three. Augmentation degree one shows +that all off-diagonal coefficient rows ((N_j)_(u,v))_j lie in this +space. The returned diagonal row lies there too. Thus the off-diagonal +patterns of the used projectors span a binary space of dimension at +most three, with the corresponding augmented condition for coordinate a. + +List all 120 binary rank-one idempotents. They have 104 distinct nonzero +off-diagonal patterns. Generate every pattern space of dimension one, +two, or three. For each space include all projectors with that pattern, +including the four coordinate projectors. An irreducible pool must have +a strongly connected union graph. This is also sufficient for the full +pool, since its coordinate projectors force invariant subspaces to be +coordinate subspaces. Quotient only by coordinate permutations. + +Dimension 1 2 3 +All spaces 104 4,964 140,281 +Full irreducible pools + 0 634 63,567 +Permutation classes + 0 45 2,846 + +Dimension zero is diagonal and reducible. List every eight-call multiset +in the remaining pools. Require actual pattern rank, the distance and +augmented conditions above, and irreducibility of the used support. +This leaves 103 rank-two families and 4,020 rank-three families. + +List every order modulo swaps of commuting factors and word reversal. +Reversal is valid by inversion and negation of all frames. Rank two +gives 27,156 canonical words, all checked by both exact engines. Rank +three gives 3,560,923 words. Here the rank-three derivative space equals +L modulo two. In F_2[(F_2)^8/(L mod 2)] the product must still be diagonal +with one monomial per entry and identity in a permitted returned entry. +Exactly 1,901,600 words pass this necessary check. + +4. Complete exact relation search +--------------------------------- +Expand each word into at most 256 subset monomials. At a partial +rational relation space R, collect equal monomials in Q^8/R. A nonzero +off-diagonal term must cancel with some other term in the same entry. +Branch over all such partners, adding their original subset-difference +row. Each step raises relation rank. Stop at rank three. + +Reject zero paid frames. At a diagonal terminal each entry is a single +monomial: the determinant is a monomial, so each diagonal factor is a +unit in a Laurent polynomial ring. For each allowed returned role, add +its original target subset indicator as a zero relation. Reject if this +needs rank four or kills a paid frame. Also reject if an active target +lies in R plus the span of any two coordinate unit vectors. Its matrix +would then lie in the span of two rank-one frames and have rank at most +two. This obstruction persists under every further relation. + +The primitive-integer engine performs exact fraction-free row operations. +The second engine uses F_101. Every state has at most three original +rows with entries in {-1,0,1}. Its RREF entries have numerator and +denominator of absolute value at most five, by minors and Cramer's rule. +Rational reconstruction is unique modulo 101 since a cross difference +is at most 50. Every equality or rank decision uses at most four such +nonunit rows, plus coordinate rows. Expansion along the coordinate +rows and Hadamard's inequality bound each relevant minor by 16. Hence +no required rational rank changes modulo 101. The same bound separates +unequal cached row spaces. Reconstructed primitive-row parities belong +to L modulo two and give a further safe first-order check. + +Both engines check every retained word. Rank two has no diagonal +terminal. Rank three has 538, with exactly matching word IDs and one +terminal each. Every terminal is rejected. No physical eight-call +solution remains. The recorded counts and input hashes are checked by +generate.py, and receipt.json records the full independent replay. + +5. Upper bound and boundary +--------------------------- +For each C_w, use its three rank-one column matrices as paid frames +with scalar projector e_w e_w^T. Their sum is C_w, so three calls give +[C_w] on register w. Nine calls give the target and fix the fourth +register. The lower bound is therefore sharp. + +The theorem does not cover clean initialized workspace, more than one +extra scalar register, noncommuting address operations, or a weaker +output contract. It does not rule out a larger-batch improvement. diff --git a/research/bit-three-active-one-returned/README.md b/research/bit-three-active-one-returned/README.md new file mode 100644 index 0000000000..1b6974786f --- /dev/null +++ b/research/bit-three-active-one-returned/README.md @@ -0,0 +1,108 @@ +# Three active targets and one returned register + +Three invertible lower-triangular rational 3 by 3 target frames need at +least nine paid calls in the formal binary scalar-register model below. +Nine calls suffice. The targets can differ. The fourth input is arbitrary +and must return unchanged. This is a scoped negative result. It gives no +new integer-multiplication exponent or kappa value. + +Each paid factor is `I + ([A]-1)N` in `F_2[M_3(Q)]`. The address frame +`A` is nonzero and has rational rank one. The scalar matrix `N` is a +binary rank-one idempotent on four registers. The endpoint is +`diag([C_1],[C_2],[C_3],1)`. The proof has no bound on rational entries. +It does not cover an input that starts at zero and has a discarded output. + +Read [PROOF.txt](PROOF.txt) and [AUDIT.txt](AUDIT.txt). The finite reduction +has a complete scalar catalogue. Two arithmetic engines check every +retained word. The original independent audit checks the catalogue and +the order coverage through different algorithms. This is a written and +computer-assisted proof, not a proof-assistant result or a human review. + +The material predecessor is [PR #468](https://github.com/CrocSwap/integer-mult-bounds/pull/468). +Its [three-register proof](https://github.com/CrocSwap/integer-mult-bounds/blob/07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea/research/bit-three-register-lower-bound/README.md) +supplies the span-four and three-register bounds. The present proof states +the extension to an unchanged fourth register. That predecessor credits +the register model and the dimension-two flag bound to +[PR #288](https://github.com/CrocSwap/integer-mult-bounds/pull/288), at +[its recorded source](https://github.com/eumemic/integer-mult-bounds/blob/475a088b5862f75f0b10596cfd6842d19531a5ec/research/negative-results-paradigm-search/README.md). +The pinned PR #468 proof also credits @huxint's +[PR #203](https://github.com/CrocSwap/integer-mult-bounds/pull/203) for the +related common triangular-frame obstruction, at +[its recorded commit](https://github.com/huxint/integer-mult-bounds/commit/d2873e20750d0949d2ad75cbc4cd82b5b1a74e84). +OpenAI Codex and research agents prepared the local proof and checks under +the user's direction. No independent human review is claimed. + +From this package directory, with Python 3.10 or later and a C++17 compiler: + +```sh +python3 -B verify.py --build /tmp/three-active-one-returned-replay +``` + +The build path must not exist. The script uses only the standard library. +It writes all generated files to that path. Set `CXX` to a compiler path +if needed. Allow about 200 MB for generated files. The wrapper checks the +saved source hashes and rejects optimized Python because the original +generator uses assertions. Python child processes ignore Python environment +options, so their assertions remain enabled. + +The final result must contain: + +```text +Exact checks: 2 27156 0 0 +Exact checks: 3 1901600 538 0 +Receipt: /receipt.json +``` + +The original source bytes and receipts are retained. `SOURCE-MANIFEST.json` +maps each one to its local origin and SHA256. `receipt.json` is the original +full replay. `replayed-receipt.json` and `replay.log` record the cleanup +audit replay. The primary replay repeats the full primary generation and +both arithmetic engines. `replayed-independent-receipt.json` and +`independent-replay.log` record a separate complete replay of the +independent front end and its seven formal-polynomial controls. + +The independent generator sources are in `independent-sources/`. After +the primary replay, run the complete independent front end with: + +```sh +python3 -B verify_independent.py --primary-build /tmp/three-active-one-returned-replay --build /tmp/three-active-one-returned-independent +``` + +The second build path must not exist. This command reconstructs the +catalogue, checks both multiset censuses and all rank-two and rank-three +orders, and binds those results to the primary binary streams. It also +runs seven formal-polynomial controls. Those controls are not paid-call +circuit constructions. Large generated inputs remain outside the package. +The unchanged historical control script requires `clang++` on `PATH`; +the other compile steps use `CXX` when it is set. + +The independent review also checked all 538 terminal words with exact +`Fraction` arithmetic. The saved historical terminal receipt is included +in `independent-sources/work/four-register/independent/`. The fresh result +is `replayed-fraction-terminals.json`. To repeat that check after the +primary replay, run: + +```sh +python3 -E -B verify_fraction_terminals.py . /tmp/three-active-one-returned-replay /tmp/three-active-one-returned-fraction.json +``` + +The original cleanup replay receipts predate the final addition of the +historical Fraction receipt to `SOURCE-MANIFEST.json`. They record the +sources and checks present at that run. The final independent review +binds the complete package, including the added receipt. + +The current [mixed-target compression result](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/bit-mixed-target-register-compression/README.md) +bounds the number of extra roles for a possible eight-call word but does +not rule that word out. The [parity-uniform target result](https://github.com/CrocSwap/integer-mult-bounds/blob/cef4b52f2a59009865bf8eabde1be3f159063703/research/bit-parity-uniform-targets/README.md) +permits arbitrary dirty workspace when all target classes agree modulo +two in the generated address lattice. This package imposes no such parity +condition and uses exactly one returned role. + +## Open next questions + +Can the same lower bound cover three distinct target frames with more +than one arbitrary returned register? The first step is to compare the +scalar compression and invariant-subspace reductions with the current +mixed-target results. The four-register catalogue does not cover the +larger scalar alphabets. This package also supplies no physical compiler +or price for an alternative circuit. diff --git a/research/bit-three-active-one-returned/REPLAY.txt b/research/bit-three-active-one-returned/REPLAY.txt new file mode 100644 index 0000000000..1cb5dfa862 --- /dev/null +++ b/research/bit-three-active-one-returned/REPLAY.txt @@ -0,0 +1,55 @@ +Replay the three-active, one-returned lower bound +================================================ + +Requirements: Python 3.10 or later, and a C++17 compiler. Only the Python +standard library is used. Set CXX to a compiler executable if needed. + +From any directory, run the saved generate.py file with a new build +folder. For example, from this package folder: + + python3 generate.py --build /tmp/three-active-one-returned-replay + +The build folder must not exist. The program writes every generated +file there. It does not write into the package or use repository files, +network access, installed Python packages, or precomputed binary inputs. +Allow about 200 MB of temporary disk space. The recorded full run took +about one minute on the author's computer; this is not a runtime bound. + +The run performs these steps: + +1. Compile the four small C++ programs. +2. Generate all pattern spaces and retained rank-two and rank-three + multisets, with the counts in PROOF.txt. +3. Generate all canonical orders and run the required finite quotient + check on rank-three words. +4. Check the exact input record counts and SHA256 hashes. +5. Run primitive-integer and F101 relation searches on every input. +6. Compare every terminal word ID and every cumulative terminal count. +7. Save receipt.json in the build folder. + +Expected final lines: + + Exact checks: 2 27156 0 0 + Exact checks: 3 1901600 538 0 + Receipt: /receipt.json + +The last two numbers in each check are diagonal terminals and accepted +relation spaces. Zero accepted spaces is the required negative result. +A surviving relation space would not itself be a circuit construction. + +The package's receipt.json is the saved full replay result. It includes +source hashes, input hashes, all catalogue counts, and both engine totals. +AUDIT.txt states the independent verification scope. No large generated +JSONL files, input records, or compiled binaries are part of the package. + +Source map: + generate.py Complete generation, replay, and result comparison. + multisets.cpp Rank-three multiset filters. + orders.cpp Rank-three commuting-order and quotient filters. + rational.cpp Primitive-integer collision engine. + field101.cpp Independent F101 collision engine. + +Both collision engines adapt the exact relation methods used in PR468. +The four C++ files are byte-identical to the separately checked working +sources. The generator combines the checked catalogue and conversion +steps. The full package was replayed in a new temporary directory. diff --git a/research/bit-three-active-one-returned/SOURCE-MANIFEST.json b/research/bit-three-active-one-returned/SOURCE-MANIFEST.json new file mode 100644 index 0000000000..90d784367c --- /dev/null +++ b/research/bit-three-active-one-returned/SOURCE-MANIFEST.json @@ -0,0 +1,167 @@ +{ + "main_pin": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "original": "outputs/three-active-one-returned/AUDIT.txt", + "package": "AUDIT.txt", + "sha256": "1d122a587e3d876005ef3362be16dc8f34aa871bed7ef6a53fcb7bc3f661a3f3", + "bytes": 17472 + }, + { + "original": "outputs/three-active-one-returned/PROOF.txt", + "package": "PROOF.txt", + "sha256": "0e36d58d380b73f3a7a32e157704681803a1f56232268acb9f97d14d23a4f78e", + "bytes": 9115 + }, + { + "original": "outputs/three-active-one-returned/REPLAY.txt", + "package": "REPLAY.txt", + "sha256": "7ec83899df66c47e3d24f988e9824ddd2fa2ae6065c6e88e62b9816fe89f71eb", + "bytes": 2515 + }, + { + "original": "outputs/three-active-one-returned/field101.cpp", + "package": "field101.cpp", + "sha256": "5995e8d4cfd7a212a083c4764d271cae15bf0baeb09b6b2897e2601065c02ed9", + "bytes": 14736 + }, + { + "original": "outputs/three-active-one-returned/generate.py", + "package": "generate.py", + "sha256": "bf6e5ae35550ef01638e27c29dcfedaabcc4868d75d2d3f54383b4da4d9a5920", + "bytes": 10838 + }, + { + "original": "outputs/three-active-one-returned/independent-receipt.json", + "package": "independent-receipt.json", + "sha256": "3078c86bc7e5ce80f0ff77e6300ca78ae4c52cad3f605bb8936c63fb2d305305", + "bytes": 4289 + }, + { + "original": "outputs/three-active-one-returned/multisets.cpp", + "package": "multisets.cpp", + "sha256": "dc508c03f0526aed029989e2d74c135f20be75b083124cc577ca218193d5666b", + "bytes": 3221 + }, + { + "original": "outputs/three-active-one-returned/orders.cpp", + "package": "orders.cpp", + "sha256": "b2c0ebe347fcc7e3744b43e59c48b97ce1f70bdb786e900b8025dc9ab59af78a", + "bytes": 4211 + }, + { + "original": "outputs/three-active-one-returned/rational.cpp", + "package": "rational.cpp", + "sha256": "590b838fd6662fb98464e1549bf23b862b2fae784984ccf419932bfe0b059c84", + "bytes": 15409 + }, + { + "original": "outputs/three-active-one-returned/receipt.json", + "package": "receipt.json", + "sha256": "ea38c17019d2f73a30b1062ec72b4736eb6dd95abbe8f09f358810323ad9fa94", + "bytes": 3041 + }, + { + "original": "work/four-register/DIRTY-MODEL.txt", + "package": "independent-sources/work/four-register/DIRTY-MODEL.txt", + "sha256": "c42806af71be2e44dc4e59c75134795db7684ce0cc57ebfaecd3da9252b77c9a", + "bytes": 3638 + }, + { + "original": "work/four-register/F101-ARITHMETIC.txt", + "package": "independent-sources/work/four-register/F101-ARITHMETIC.txt", + "sha256": "540dfa9f49488b92ee24e9f82704ac2032aa2117957dd4c9cbcf33ca4fafe09f", + "bytes": 3513 + }, + { + "original": "work/four-register/dirty_ancilla.py", + "package": "independent-sources/work/four-register/dirty_ancilla.py", + "sha256": "81d8df0b7b08e0ad89dc13f65325e7091cb9c201d9c5bc4d8637f8325d0be876", + "bytes": 6293 + }, + { + "original": "work/four-register/dirty_h_alphabet.py", + "package": "independent-sources/work/four-register/dirty_h_alphabet.py", + "sha256": "0f889a71e9d14b26cc5fc226f4ef72ab276a2ce71b11cd3535c50be1bc4ad5dd", + "bytes": 4551 + }, + { + "original": "work/four-register/dirty_rank2.py", + "package": "independent-sources/work/four-register/dirty_rank2.py", + "sha256": "51da1918d6219dfb2a59d4a6c27885d41113cc3c07a8f659d7df0254d5b7d3c7", + "bytes": 2323 + }, + { + "original": "work/four-register/dirty_f101_controls.py", + "package": "independent-sources/work/four-register/dirty_f101_controls.py", + "sha256": "d42cdf78c7a58f011c34d54a7fb1881c4a81fbe6179571d096cbe58ca81c5331", + "bytes": 2729 + }, + { + "original": "work/four-register/independent/off_pattern_spaces.py", + "package": "independent-sources/work/four-register/independent/off_pattern_spaces.py", + "sha256": "51ef2a52c9639bb2a236e68d912a1d5877600e4956083ec9015420bca5adbd50", + "bytes": 2023 + }, + { + "original": "work/four-register/independent/rank3_data.py", + "package": "independent-sources/work/four-register/independent/rank3_data.py", + "sha256": "d7021e4d59bffd3cc17456841186b464bc91f18c878ec6eded7fac6ade393b19", + "bytes": 1867 + }, + { + "original": "work/four-register/independent/rank2_binary.py", + "package": "independent-sources/work/four-register/independent/rank2_binary.py", + "sha256": "6231b6fde84fc680285dd2816a8d3f362ae35563435d5c1a4eb3bb512a47b10d", + "bytes": 1747 + }, + { + "original": "work/four-register/independent-audit/check_off_catalogue.py", + "package": "independent-sources/work/four-register/independent-audit/check_off_catalogue.py", + "sha256": "e4c07f111a59e15b66fd99035e75ac99df5bee6c3fb48792f08022003b92592e", + "bytes": 3810 + }, + { + "original": "work/four-register/independent-audit/check_input_binding.py", + "package": "independent-sources/work/four-register/independent-audit/check_input_binding.py", + "sha256": "6ff60a74b38d7e7cbc480fd751df2209c0f9181f20b8f20f51ed644b69c5b578", + "bytes": 3164 + }, + { + "original": "work/four-register/independent-audit/check_rank2_orders.py", + "package": "independent-sources/work/four-register/independent-audit/check_rank2_orders.py", + "sha256": "58dff791aabf5834816465e2fc0e451eb38a20d99affd5d16fed2d37f328e976", + "bytes": 3357 + }, + { + "original": "work/four-register/independent-audit/check_rank3_multisets.cpp", + "package": "independent-sources/work/four-register/independent-audit/check_rank3_multisets.cpp", + "sha256": "c7a34479a2229fe3151d50ffb9ba676e7510d7cb7c21f3dbc3a42401ec2c8084", + "bytes": 4331 + }, + { + "original": "work/four-register/independent-audit/check_rank3_orders.cpp", + "package": "independent-sources/work/four-register/independent-audit/check_rank3_orders.cpp", + "sha256": "7b6b915422ba6c2443ab72f6a8f16a994416cf6e4f9ed3425c76a94cac79db48", + "bytes": 6002 + }, + { + "original": "work/four-register/independent-audit/PROOF-AUDIT.txt", + "package": "independent-sources/work/four-register/independent-audit/PROOF-AUDIT.txt", + "sha256": "c9744f9895dd59bf7c9e05df2dbbebcc440b33ab86e829a054ae61ed5518ec12", + "bytes": 8163 + }, + { + "original": "work/four-register/independent-audit/DIRTY-AUDIT.txt", + "package": "independent-sources/work/four-register/independent-audit/DIRTY-AUDIT.txt", + "sha256": "1d122a587e3d876005ef3362be16dc8f34aa871bed7ef6a53fcb7bc3f661a3f3", + "bytes": 17472 + }, + { + "original": "work/four-register/independent/fraction-terminal-audit.json", + "package": "independent-sources/work/four-register/independent/fraction-terminal-audit.json", + "sha256": "c9bf5d77f3e7127828f8d35657d9c3d2c4a4a12aa3143f62219021355c3d2a20", + "bytes": 88380 + } + ] +} diff --git a/research/bit-three-active-one-returned/field101.cpp b/research/bit-three-active-one-returned/field101.cpp new file mode 100644 index 0000000000..4de2e4773b --- /dev/null +++ b/research/bit-three-active-one-returned/field101.cpp @@ -0,0 +1,443 @@ +// Check four-register subset collisions with exact row reduction over F101. +// This file is derived from the PR468 field engine. +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using Row = std::array; + +int prod[101][101], inverse[101], num[101], den[101], outer_table[16][16]; +constexpr int ID = 33825; +const int OFF_BITS[12] = {1,2,3,4,6,7,8,9,11,12,13,14}; + +int minus_product(int a, int t, int b) { + int q = a - prod[t][b]; + return q < 0 ? q + 101 : q; +} + +struct Basis { + std::array a{}; + std::array p{}; + int n = 0; + + bool operator==(const Basis& b) const { return a == b.a; } +}; + +struct BasisHash { + size_t operator()(const Basis& b) const { + size_t h = 0xcbf29ce484222325ULL; + for (const auto& r : b.a) + for (int x : r) + h = (h ^ x) * 0x100000001b3ULL; + return h; + } +}; + +Row subset(int m) { + Row v{}; + for (int i = 0; i < 8; ++i) + v[i] = (m >> i) & 1; + return v; +} + +Row residual(Row v, const Basis& b) { + for (int i = 0; i < b.n; ++i) { + int t = v[b.p[i]]; + if (t) + for (int j = b.p[i]; j < 8; ++j) + v[j] = minus_product(v[j], t, b.a[i][j]); + } + return v; +} + +Basis insert(Basis b, Row v) { + v = residual(v, b); + int p = 0; + while (p < 8 && !v[p]) + ++p; + if (p == 8) + return b; + if (b.n == 3) + throw std::logic_error("A state has too many relations"); + + int q = inverse[v[p]]; + for (int j = p; j < 8; ++j) + v[j] = prod[v[j]][q]; + for (int i = 0; i < b.n; ++i) { + int t = b.a[i][p]; + if (t) + for (int j = p; j < 8; ++j) + b.a[i][j] = minus_product(b.a[i][j], t, v[j]); + } + int at = b.n; + while (at && b.p[at - 1] > p) { + b.a[at] = b.a[at - 1]; + b.p[at] = b.p[at - 1]; + --at; + } + b.a[at] = v; + b.p[at] = p; + ++b.n; + return b; +} + +int binrank(const std::vector& rows) { + int b[8]{}, n = 0; + for (int v : rows) { + for (int k = 7; k >= 0; --k) { + if (!((v >> k) & 1)) + continue; + if (b[k]) { + v ^= b[k]; + } else { + b[k] = v; + ++n; + break; + } + } + } + return n; +} + +int primitive_parity(const Row& r) { + int d = 1; + for (int x : r) { + if (!den[x]) + throw std::logic_error("Rational reconstruction exceeds the proved bound"); + d = std::lcm(d, den[x]); + } + int v[8], g = 0; + for (int i = 0; i < 8; ++i) { + v[i] = num[r[i]] * (d / den[r[i]]); + g = std::gcd(g, std::abs(v[i])); + } + int bits = 0; + for (int i = 0; i < 8; ++i) + bits |= (std::abs(v[i] / g) & 1) << i; + return bits; +} + +struct GeneralBasis { + std::array a{}; + std::array p{}; + int n = 0; + + explicit GeneralBasis(const Basis& b) { + n = b.n; + for (int i = 0; i < n; ++i) { + a[i] = b.a[i]; + p[i] = b.p[i]; + } + } + + bool add(Row v) { + for (int i = 0; i < n; ++i) { + int t = v[p[i]]; + if (t) + for (int j = p[i]; j < 8; ++j) + v[j] = minus_product(v[j], t, a[i][j]); + } + int j = 0; + while (j < 8 && !v[j]) + ++j; + if (j == 8) + return false; + int q = inverse[v[j]]; + for (int k = j; k < 8; ++k) + v[k] = prod[v[k]][q]; + int at = n; + while (at && p[at - 1] > j) { + a[at] = a[at - 1]; + p[at] = p[at - 1]; + --at; + } + a[at] = v; + p[at] = j; + ++n; + return true; + } +}; + +bool target_small(int mask, const Basis& b) { + if (__builtin_popcount(static_cast(mask)) <= 2) + return true; + for (int i = 0; i < 8; ++i) { + for (int j = i + 1; j < 8; ++j) { + GeneralBasis g(b); + g.add(subset(1 << i)); + g.add(subset(1 << j)); + if (!g.add(subset(mask))) + return true; + } + } + return false; +} + +struct Group { + uint64_t key; + int mask, coefficient; +}; + +struct Search { + std::array word; + int ancillas = 15; + uint64_t index = 0; + std::array diagonal{}; + std::vector> terms; + std::vector off; + std::unordered_set visited; + uint64_t states[4]{}, parity = 0, zero = 0, terminals = 0; + uint64_t robust = 0, not_monomial = 0; + + void start() { + int coefficients[256]{}; + coefficients[0] = ID; + for (int j = 0; j < 8; ++j) { + int x = 0, y = 0; + for (int i = 0; i < 4; ++i) { + int row = (word[j] >> (4*i)) & 15; + if (row) { + if (y && y != row) throw std::logic_error("A projector has rank greater than one"); + y = row; x |= 1 << i; + } + } + if (!x || !y || !(__builtin_parity(unsigned(x&y)))) + throw std::logic_error("A projector is not a nonzero rank-one idempotent"); + for (int m = 0; m < (1 << j); ++m) { + int c = coefficients[m], u = 0; + for (int i = 0; i < 4; ++i) + u |= __builtin_parity(unsigned(((c >> (4*i)) & 15) & x)) << i; + int right = outer_table[u][y]; + coefficients[m] = c ^ right; + coefficients[m | (1 << j)] = right; + } + } + for (int m = 0; m < 256; ++m) + if (coefficients[m]) + terms.emplace_back(m, coefficients[m]); + for (int bit : OFF_BITS) { + int v = 0; + for (int j = 0; j < 8; ++j) + v |= ((word[j] >> bit) & 1) << j; + off.push_back(v); + } + for (int w = 0; w < 4; ++w) + for (int j = 0; j < 8; ++j) + diagonal[w] |= ((word[j] >> (5*w)) & 1) << j; + go(Basis{}); + } + + int allowed(const Basis& b) const { + auto ps = off; + for (int i = 0; i < b.n; ++i) ps.push_back(primitive_parity(b.a[i])); + if (binrank(ps) > 3) return 0; + int result = 0; + for (int w = 0; w < 4; ++w) if ((ancillas >> w) & 1) { + ps.push_back(diagonal[w]); + if (binrank(ps) <= 3) result |= 1 << w; + ps.pop_back(); + } + return result; + } + + bool nonzero_frames(const Basis& b) const { + for (int i = 0; i < b.n; ++i) { + int count = 0; + for (int v : b.a[i]) count += v != 0; + if (count == 1) return false; + } + return true; + } + + void go(const Basis& b) { + if (!visited.insert(b).second) + return; + ++states[b.n]; + int possible = allowed(b); + if (!possible) { ++parity; return; } + if (!nonzero_frames(b)) { ++zero; return; } + + std::unordered_map positions; + std::vector groups; + positions.reserve(terms.size()); + groups.reserve(terms.size()); + for (auto [mask, c] : terms) { + auto v = residual(subset(mask), b); + uint64_t key = 0; + for (int j = 0; j < 8; ++j) + key |= uint64_t(v[j]) << (7 * j); + auto [it, fresh] = positions.emplace(key, int(groups.size())); + if (fresh) + groups.push_back({key, mask, c}); + else + groups[it->second].coefficient ^= c; + } + + std::vector active; + int counts[16]{}; + for (auto g : groups) { + if (g.coefficient) { + active.push_back(g); + for (int bit : OFF_BITS) + counts[bit] += (g.coefficient >> bit) & 1; + } + } + int chosen = -1; + for (int bit : OFF_BITS) + if (counts[bit] && (chosen < 0 || counts[bit] < counts[chosen])) + chosen = bit; + + if (chosen < 0) { + int target[4] = {-1, -1, -1, -1}; + for (auto g : active) { + for (int w = 0; w < 4; ++w) { + if ((g.coefficient >> (5 * w)) & 1) { + if (target[w] >= 0) { + ++not_monomial; + return; + } + target[w] = g.mask; + } + } + } + for (int m : target) { + if (m < 0) { + ++not_monomial; + return; + } + } + ++terminals; + for (int anc = 0; anc < 4; ++anc) if ((possible >> anc) & 1) { + Row v = residual(subset(target[anc]), b); + bool independent = std::any_of(v.begin(), v.end(), [](int x){return x != 0;}); + if (independent && b.n == 3) continue; + Basis c = independent ? insert(b, subset(target[anc])) : b; + if (!nonzero_frames(c) || !((allowed(c) >> anc) & 1)) continue; + bool small = false; + for (int w = 0; w < 4; ++w) + if (w != anc && target_small(target[w], c)) small = true; + if (small) continue; + ++robust; + std::cerr << "ROBUST " << index << " ancilla " << anc; + for (int n : word) std::cerr << ' ' << n; + std::cerr << " relations"; + for (int i = 0; i < c.n; ++i) { + std::cerr << " ["; + for (int k = 0; k < 8; ++k) std::cerr << int(c.a[i][k]) << ','; + std::cerr << ']'; + } + std::cerr << '\n'; + return; + } + return; + } + + if (b.n == 3) + return; + int first = 0; + while (!((active[first].coefficient >> chosen) & 1)) + ++first; + for (int j = first + 1; j < int(active.size()); ++j) { + if ((active[j].coefficient >> chosen) & 1) { + Row v{}; + for (int k = 0; k < 8; ++k) { + int t = ((active[first].mask >> k) & 1) - + ((active[j].mask >> k) & 1); + v[k] = t < 0 ? 100 : t; + } + auto c = insert(b, v); + if (c.n != b.n + 1) + throw std::logic_error("A partner is already in the same group"); + go(c); + } + } + } +}; + +void setup() { + for (int a = 0; a < 101; ++a) + for (int b = 0; b < 101; ++b) + prod[a][b] = (a * b) % 101; + for (int a = 1; a < 101; ++a) + for (int b = 1; b < 101; ++b) + if (prod[a][b] == 1) + inverse[a] = b; + for (int d = 1; d <= 5; ++d) { + for (int n = -5; n <= 5; ++n) { + if (std::gcd(std::abs(n), d) == 1) { + int x = prod[(n + 101) % 101][inverse[d]]; + if (den[x] && (num[x] != n || den[x] != d)) + throw std::logic_error("Rational reconstruction is not unique"); + num[x] = n; + den[x] = d; + } + } + } + for (int x = 0; x < 16; ++x) + for (int y = 0; y < 16; ++y) + for (int i = 0; i < 4; ++i) + if ((x >> i) & 1) outer_table[x][y] |= y << (4*i); +} + +int main(int argc, char** argv) { + try { + if (argc != 3) throw std::runtime_error("Usage: dirty_f101 INPUT_BINARY RESULTS_JSONL"); + setup(); + std::ifstream input(argv[1], std::ios::binary); + if (!input) throw std::runtime_error("Cannot open binary input"); + input.seekg(0,std::ios::end); + auto size = input.tellg(); + if (size < 0 || size % 18) throw std::runtime_error("Input size is not divisible by 18"); + input.seekg(0); + uint64_t count = uint64_t(size)/18, totals[4]{}, terminal=0, robust=0, parity=0, zero=0, invalid=0; + uint64_t hash = 0xcbf29ce484222325ULL; + std::ofstream output(argv[2]); + if (!output) throw std::runtime_error("Cannot open output"); + std::ofstream terminal_output(std::string(argv[2])+".terminals.jsonl"); + if (!terminal_output) throw std::runtime_error("Cannot open terminal output"); + auto begun = std::chrono::steady_clock::now(); + for (uint64_t index=0; index(bytes),18); + if (!input) throw std::runtime_error("Incomplete binary record"); + Search search; + search.index=index; + for (int j=0;j<8;++j) search.word[j]=bytes[2*j]+256*bytes[2*j+1]; + search.ancillas=bytes[16]+256*bytes[17]; + if (search.ancillas<1 || search.ancillas>15) throw std::runtime_error("Invalid ancilla mask"); + for (int b:bytes) hash=(hash^b)*0x100000001b3ULL; + search.start(); + if (search.terminals) { + terminal_output << "{\"word\":" << index << ",\"terminals\":" << search.terminals << ",\"robust\":" << search.robust << "}\n"; + if (!terminal_output) throw std::runtime_error("Cannot write terminal output"); + } + for(int k=0;k<4;++k)totals[k]+=search.states[k]; + terminal+=search.terminals;robust+=search.robust;parity+=search.parity;zero+=search.zero;invalid+=search.not_monomial; + if ((index+1)%1000==0 || index+1==count) { + output << "{\"words\":" << index+1 << ",\"states\":[" << totals[0] << ',' << totals[1] << ',' << totals[2] << ',' << totals[3] + << "],\"terminals\":" << terminal << ",\"robust\":" << robust << ",\"parity_prunes\":" << parity + << ",\"zero_frame_prunes\":" << zero << ",\"nonmonomial_diagonal\":" << invalid << ",\"input_fnv64\":" << hash << "}\n"; + output.flush(); + if(!output)throw std::runtime_error("Cannot write output"); + } + if ((index+1)%10000==0 || index+1==count) { + double seconds=std::chrono::duration(std::chrono::steady_clock::now()-begun).count(); + std::cerr << index+1 << '/' << count << " words, " << robust << " robust, " << seconds << " seconds\n"; + } + } + return 0; + } catch(const std::exception& error) { + std::cerr << error.what() << '\n'; return 1; + } +} diff --git a/research/bit-three-active-one-returned/generate.py b/research/bit-three-active-one-returned/generate.py new file mode 100644 index 0000000000..cc89da210d --- /dev/null +++ b/research/bit-three-active-one-returned/generate.py @@ -0,0 +1,259 @@ +"""Rebuild the complete scalar catalogue and run two exact relation checks.""" +import argparse +import hashlib +import itertools +import json +import os +from pathlib import Path +import shutil +import struct +import subprocess +import time + +SOURCE = Path(__file__).resolve().parent +OFF = 0x7bde +PERMUTATIONS = list(itertools.permutations(range(4))) +EXPECTED_INPUTS = { + 2: (27156, 'f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee'), + 3: (1901600, '97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911'), +} + + +def outer(x, y): + return sum(y << (4*i) for i in range(4) if x >> i & 1) + + +def rank(vectors): + pivots = {} + for v in vectors: + while v: + k = v.bit_length()-1 + if k in pivots: + v ^= pivots[k] + else: + pivots[k] = v + break + return len(pivots) + + +def strong(space): + edges = 0 + for v in space: + edges |= v + for start in range(4): + seen = 1 << start + while True: + nxt = seen + for j in range(4): + if seen >> j & 1: + nxt |= (edges >> (4*j)) & 15 + if nxt == seen: + break + seen = nxt + if seen != 15: + return False + return True + + +def canonical(space): + return min(tuple(sorted(sum(((v >> (4*i+j)) & 1) << (4*p[i]+p[j]) + for i in range(4) for j in range(4)) for v in space)) + for p in PERMUTATIONS) + + +def catalogue(): + projectors = [(x, y, outer(x, y)) for x in range(1, 16) + for y in range(1, 16) if (x & y).bit_count() % 2] + patterns = sorted({m & OFF for x, y, m in projectors}-{0}) + spaces = {(0,)} + levels = [] + for dimension in range(1, 4): + nxt = set() + for space in spaces: + for v in patterns: + if v not in space: + nxt.add(tuple(sorted(space+tuple(x ^ v for x in space)))) + spaces = nxt + irred = [s for s in spaces if strong(s)] + reps = sorted({canonical(s) for s in irred}) + levels.append({'dimension': dimension, 'spaces': len(spaces), + 'irreducible_spaces': len(irred), + 'representatives': [{'space': s, 'projectors': [(x, y) for x, y, m in projectors if m & OFF in s]} for s in reps]}) + print('Catalogue:', dimension, len(spaces), len(irred), len(reps), flush=True) + assert [(r['spaces'], r['irreducible_spaces'], len(r['representatives'])) for r in levels] == [(104, 0, 0), (4964, 634, 45), (140281, 63567, 2846)] + return levels + + +def irreducible(projectors): + for start in range(1, 16): + span = {0, start} + while True: + old = set(span) + for x, y in projectors: + if x not in span and any((v & y).bit_count() % 2 for v in span): + span |= {v ^ x for v in tuple(span)} + if span == old: + break + if len(span) < 16: + return False + return True + + +def normalize(word, commute): + left = list(range(len(word))) + result = [] + while left: + choices = [i for i in left if all(commute[word[j]][word[i]] for j in left if j < i)] + i = min(choices, key=lambda j: (word[j], j)) + result.append(word[i]) + left.remove(i) + return tuple(result) + + +def orders(counts, commute, word=()): + if not any(counts): + if word <= normalize(word[::-1], commute): + yield word + return + for j, count in enumerate(counts): + if not count: + continue + blocked = False + for old in reversed(word): + if not commute[old][j]: + break + if old > j: + blocked = True + break + if blocked: + continue + counts[j] -= 1 + yield from orders(counts, commute, word+(j,)) + counts[j] += 1 + + +def rank_two(pools, build): + families = [] + multisets = 0 + for pool_index, pool in enumerate(pools): + ns = pool['projectors'] + cached = {} + for choice in itertools.combinations_with_replacement(range(len(ns)), 8): + multisets += 1 + counts = [choice.count(i) for i in range(len(ns))] + support = tuple(i for i, c in enumerate(counts) if c) + if rank([outer(*ns[i]) & OFF for i in support]) != 2: + continue + allowed = set(range(4)) + for side in (0, 1): + for r in range(1, 16): + if sum(counts[i]*((r & ns[i][side]).bit_count() % 2) for i in support) < 3: + allowed &= {r.bit_length()-1} if r.bit_count() == 1 else set() + if not allowed: + continue + if support not in cached: + cached[support] = irreducible([ns[i] for i in support]) + if not cached[support]: + continue + allowed = [a for a in sorted(allowed) if rank([outer(*ns[i]) & (OFF | 1 << (5*a)) for i in support]) <= 3] + if allowed: + families.append({'pool': pool_index, 'projectors': ns, 'counts': counts, 'ancillas': allowed}) + assert multisets == 61347 and len(families) == 103 + count = 0 + with (build/'rank2.bin').open('wb') as f: + for family in families: + ns = family['projectors'] + commute = [[a == b or (not ((a[0] & b[1]).bit_count() % 2) and not ((b[0] & a[1]).bit_count() % 2)) for b in ns] for a in ns] + for word in orders(list(family['counts']), commute): + f.write(struct.pack('<9H', *(outer(*ns[i]) for i in word), sum(1 << a for a in family['ancillas']))) + count += 1 + return {'multisets': multisets, 'families': len(families), 'words': count} + + +def run(command, output, errors): + with output.open('w') as out, errors.open('w') as err: + subprocess.run([str(x) for x in command], stdout=out, stderr=err, check=True) + + +def rank_three(pools, build): + with (build/'pools.txt').open('w') as f: + f.write(f'{len(pools)}\n') + for pool in pools: + s = pool['space'] + assert all(s[i] ^ s[j] == s[i ^ j] for i in range(8) for j in range(8)) + f.write(f"{len(pool['projectors'])}\n") + for x, y in pool['projectors']: + f.write(f'{x} {y} {s.index(outer(x, y) & OFF)}\n') + run([build/'multisets', build/'pools.txt'], build/'multisets.jsonl', build/'multisets.log') + families = [json.loads(line) for line in (build/'multisets.jsonl').read_text().splitlines()] + with (build/'orders.txt').open('w') as f: + f.write(f'{len(families)}\n') + for family in families: + ns = pools[family['class']]['projectors'] + f.write(f"{len(ns)} {family['possible_ancilla']}\n") + for (x, y), count in zip(ns, family['counts']): + f.write(f'{x} {y} {count}\n') + run([build/'orders', build/'orders.txt'], build/'orders.jsonl', build/'orders.log') + count = 0 + with (build/'rank3.bin').open('wb') as out, (build/'orders.jsonl').open() as inp: + for line in inp: + row = json.loads(line) + ns = pools[families[row['family']]['class']]['projectors'] + out.write(struct.pack('<9H', *(outer(*ns[i]) for i in row['order']), row['ancilla_mask'])) + count += 1 + multiset_stats = json.loads((build/'multisets.log').read_text().splitlines()[-1]) + order_stats = json.loads((build/'orders.log').read_text().splitlines()[-1]) + assert multiset_stats == {'classes': 2846, 'multisets': 11210628, 'distance_ok': 8623, 'rank_ok': 4020, 'irreducible': 4020} + assert order_stats == {'families': 4020, 'prefixes': 28785353, 'commutation_orders': 7121514, 'reversal_orders': 3560923, 'parity_survivors': 1901600} + assert count == order_stats['parity_survivors'] + return {'multisets': multiset_stats, 'orders': order_stats} + + +def json_lines(path): + return [json.loads(line) for line in path.read_text().splitlines()] + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--build', required=True, type=Path, help='New directory for all generated files') + args = parser.parse_args() + build = args.build.resolve() + build.mkdir(parents=True, exist_ok=False) + compiler = os.environ.get('CXX') or shutil.which('clang++') or shutil.which('g++') + if not compiler: + raise RuntimeError('A C++17 compiler is required') + started = time.time() + for name in ('multisets', 'orders', 'rational', 'field101'): + subprocess.run([compiler, '-O3', '-std=c++17', str(SOURCE/(name+'.cpp')), '-o', str(build/name)], check=True) + levels = catalogue() + result = {'rank2': rank_two(levels[1]['representatives'], build), + 'rank3': rank_three(levels[2]['representatives'], build), 'inputs': {}, 'engines': {}} + for dimension in (2, 3): + inp = build/f'rank{dimension}.bin' + count, digest = EXPECTED_INPUTS[dimension] + actual = hashlib.sha256(inp.read_bytes()).hexdigest() + assert inp.stat().st_size == 18*count and actual == digest + result['inputs'][str(dimension)] = {'records': count, 'sha256': actual} + rational = build/f'rational{dimension}' + field = build/f'field{dimension}.jsonl' + run([build/'rational', inp, rational, 'dirty'], build/f'rational{dimension}.summary.json', build/f'rational{dimension}.log') + run([build/'field101', inp, field], build/f'field{dimension}.stdout', build/f'field{dimension}.log') + a = json_lines(Path(str(rational)+'.chunks.jsonl')) + b = json_lines(field) + ta = json_lines(Path(str(rational)+'.terminals.jsonl')) + tb = json_lines(Path(str(field)+'.terminals.jsonl')) + assert ta == tb + assert [(r['end'], r['terminals'], r['robust']) for r in a] == [(r['words'], r['terminals'], r['robust']) for r in b] + assert a[-1]['end'] == count and a[-1]['terminals'] == (0 if dimension == 2 else 538) and a[-1]['robust'] == 0 + result['engines'][str(dimension)] = {'rational': a[-1], 'field101': b[-1], 'terminal_word_agreement': True, 'chunk_agreement': True} + print('Exact checks:', dimension, count, a[-1]['terminals'], 0, flush=True) + result['catalogue'] = [{k: v for k, v in r.items() if k != 'representatives'} | {'classes': len(r['representatives'])} for r in levels] + result['source_sha256'] = {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in sorted(SOURCE.iterdir()) if p.suffix in ('.cpp', '.py')} + result['seconds'] = time.time()-started + result['status'] = 'PASS_COMPLETE_FINITE_CHECKS' + (build/'receipt.json').write_text(json.dumps(result, indent=2)+'\n') + print('Receipt:', build/'receipt.json', flush=True) + + +if __name__ == '__main__': + main() diff --git a/research/bit-three-active-one-returned/independent-receipt.json b/research/bit-three-active-one-returned/independent-receipt.json new file mode 100644 index 0000000000..5052ad6beb --- /dev/null +++ b/research/bit-three-active-one-returned/independent-receipt.json @@ -0,0 +1,97 @@ +{ + "status": "PASS_SCOPED_FOUR_REGISTER_COMPLETENESS_AUDIT", + "theorem": "Three invertible lower-triangular rational 3x3 targets and one arbitrary returned scalar register need at least nine nonzero rank-one rational calls in the binary rank-one-idempotent all-input model. Nine calls attain this minimum.", + "dependencies": [ + "PR468 span-at-most-four lower bound, with active target count", + "PR468 three-register eight-call impossibility" + ], + "independent_receipts": { + "OFF-CATALOGUE-RESULT.json": { + "status": "PASS_INDEPENDENT_OFF_PATTERN_CATALOGUE", + "projectors": 120, + "nonzero_off_patterns": 104, + "levels": [ + { + "dimension": 1, + "spaces": 104, + "strongly_connected_spaces": 0, + "classes": 0, + "representatives_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "eight_multisets": 0 + }, + { + "dimension": 2, + "spaces": 4964, + "strongly_connected_spaces": 634, + "classes": 45, + "representatives_sha256": "55a3766dbfeb7e83ffbeba2ac6f172d1a7c3eeb9653a2ee634f95ba82f85950b", + "eight_multisets": 61347 + }, + { + "dimension": 3, + "spaces": 140281, + "strongly_connected_spaces": 63567, + "classes": 2846, + "representatives_sha256": "83f52db23039b19bcaee7e94b05fd2b2c2033a3a41998c665aa5e6bdd537afc8", + "eight_multisets": 11210628 + } + ] + }, + "rank3-multisets-summary.json": { + "classes": 2846, + "multisets": 11210628, + "accepted": 4020, + "proper_subspaces": 65 + }, + "INPUT-BINDING-RESULT.json": { + "status": "PASS_CATALOGUE_MULTISET_WORD_BINARY_BINDING", + "pool_classes": 2846, + "multiset_rows": 4020, + "independent_multiset_rows": 4020, + "binary_records": 1901600, + "binary_bytes": 34228800, + "binary_sha256": "97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911" + }, + "RANK3-ORDERS-RESULT.json": { + "status": "PASS_INDEPENDENT_RANK3_ORDER_AND_QUOTIENT_REPLAY", + "families": 4020, + "raw_orders": 41706000, + "commutation_orders": 7121514, + "reversal_orders": 3560923, + "quotient_survivors": 1901600, + "binary_word_and_role_stream_identical": true + }, + "rank2-multisets-summary.json": { + "classes": 45, + "multisets": 61347, + "accepted": 103, + "proper_subspaces": 65 + }, + "RANK2-FRONT-END-RESULT.json": { + "status": "PASS_INDEPENDENT_RANK2_FRONT_END", + "families": 103, + "raw_orders": 831600, + "commutation_orders": 54294, + "reversal_orders": 27156, + "binary_word_and_role_stream_identical": true, + "binary_bytes": 488808, + "binary_sha256": "f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee" + } + }, + "reviewed_file_sha256": { + "work/four-register/independent-audit/OFF-CATALOGUE-RESULT.json": "95b581ca2ad5398f70749c054191c76cb369d73d93b9d257dd2a9096a9a7db29", + "work/four-register/independent-audit/rank3-multisets-summary.json": "4e44eff43c80ebe0b93321e5a516772f10e913c3dc83f0e43c776fd5028d73e3", + "work/four-register/independent-audit/INPUT-BINDING-RESULT.json": "906dcc3aa53f74e77927ce888366a64bf4bd6e15efc6f22b575b75e7427e84fb", + "work/four-register/independent-audit/RANK3-ORDERS-RESULT.json": "ae5bcfd6b75076d59686ddf2e814c6db30c4998bf5740e65bd73210df32b733d", + "work/four-register/independent-audit/rank2-multisets-summary.json": "4e8846f40d61800124032046cb144fd66d64a901416a0667c8a2427128e84335", + "work/four-register/independent-audit/RANK2-FRONT-END-RESULT.json": "e47ea4428cc21fe410e8310ff576c21fa3e40ea359e3309b3207aea1a57f4fe4", + "work/four-register/independent-audit/DIRTY-AUDIT.txt": "1d122a587e3d876005ef3362be16dc8f34aa871bed7ef6a53fcb7bc3f661a3f3", + "work/four-register/dirty_f101.cpp": "5995e8d4cfd7a212a083c4764d271cae15bf0baeb09b6b2897e2601065c02ed9", + "work/four-register/independent/integer_engine.cpp": "590b838fd6662fb98464e1549bf23b862b2fae784984ccf419932bfe0b059c84" + }, + "limitations": [ + "No direct kappa gain.", + "Not a lower bound for more scalar registers or different paid primitives.", + "No formal proof assistant verification." + ] +} diff --git a/research/bit-three-active-one-returned/independent-replay.log b/research/bit-three-active-one-returned/independent-replay.log new file mode 100644 index 0000000000..f793ac1343 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-replay.log @@ -0,0 +1,12 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent/off_pattern_spaces.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_off_catalogue.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/dirty_rank2.py +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_multisets.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_multisets +Run: /usr/bin/clang++ -O3 -std=c++17 /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_orders.cpp -o /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_orders +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_multisets /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/rank2-pools.txt 2 +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_multisets /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent/rank3-pools.txt +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_input_binding.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank2_orders.py +Run: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent-audit/check_rank3_orders /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent/rank3-word-input.txt /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/independent/rank3-words.bin +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-independent/work/four-register/dirty_f101_controls.py +PASS_INDEPENDENT_RETURNED_REGISTER_FRONT_END diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/DIRTY-MODEL.txt b/research/bit-three-active-one-returned/independent-sources/work/four-register/DIRTY-MODEL.txt new file mode 100644 index 0000000000..e2cff41952 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/DIRTY-MODEL.txt @@ -0,0 +1,64 @@ +Three active targets and one returned register +============================================= + +The target is diag([C_1],[C_2],[C_3],1). Each C_i is an invertible +lower-triangular rational 3 by 3 matrix. The fourth input is arbitrary. +The complete fourth row and column must be those of the identity. An +eight-call solution would use four scalar registers. The three-register +lower bound in PR468 does not by itself exclude this model. + +The span-four lemma extends to zero target frames. In its proof, replace +W in each target-minus-identity rank bound by the number of active +invertible targets. Select an active C_1 for the common-ratio flag +argument. A zero target remains zero in every projected block. All +active targets retain invertible projected blocks. Thus a frame span +of dimension at most four needs at least three calls per active target. +An eight-call solution with three active targets has frame span at +least five and relation-space dimension at most three. + +Two active targets need at least six calls even with any number of +returned registers. For a putative word with at most five calls, a +frame span of dimension at most four is covered by the preceding +lemma. The only remaining case has five independent frames. Distinct +subset sums then cannot cancel. Each off-diagonal polynomial coefficient +is zero, and differentiation at one makes every scalar projector +diagonal. The calls are disjoint by target role. Rank subadditivity +then requires three calls for each of the two active targets. + +One active target needs at least three calls. Its frame belongs to the +span of all paid frames, by projection with rational functionals. Fewer +than three rank-one frames cannot span an invertible 3 by 3 matrix. + +A three-active, one-returned eight-call word must therefore be scalar +irreducible. A common proper binary invariant subspace splits the +target characters between smaller blocks. If both blocks have active +targets, the counts are one and two and require at least 3+6 calls. +If one block has all three active targets, it has scalar size three, +so PR468 requires at least nine calls. Repeated target characters do +not cause a problem: split the invariant binary subspace within each +repeated-character space before taking the diagonal blocks. + +For a possible returned coordinate w, each nonzero binary row r other +than e_w must meet at least three x vectors. The same condition holds +for y vectors. Otherwise a rational functional can kill the at most +two frames seen by r while remaining nonzero on an active target in +its support. The projected circuit fixes r, but its target does not. + +There is one more first-order condition. Delete the three active +diagonal entries from each binary projector N_j. The resulting pattern +vectors span a binary space of dimension at most three. The omitted +entries may have nonzero target derivatives. All other entries, +including the returned diagonal entry, have zero target derivatives. +Their derivative rows lie in the reduction modulo two of the saturated +integer relation lattice, which has dimension at most three. + +The dirty_ancilla.py checker uses exact rational collision branching. +At a diagonal terminal it tries each returned role w and adds the +relation C_w=0. It then checks that each of the other three target +frames is not in the span of any two paid frames. An accepted terminal +would still need a rank-one rational matrix realization and a complete +formal identity check. + +The two-active lower bound and scalar-irreducibility extension were +reviewed by the root agent. An independent audit of the dirty checker +and H/coordinate alphabet catalogue is in progress. diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/F101-ARITHMETIC.txt b/research/bit-three-active-one-returned/independent-sources/work/four-register/F101-ARITHMETIC.txt new file mode 100644 index 0000000000..ad49238fed --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/F101-ARITHMETIC.txt @@ -0,0 +1,64 @@ +Exact arithmetic for the eight-call returned-register search +============================================================ + +The state is a rational subspace of Q^8 with dimension at most three. +Each generating relation is one of these original rows: + +1. The difference of two subset indicator vectors. Each entry is -1, 0, + or 1. +2. At a diagonal terminal, the original subset indicator for the target + of the returned register. Each entry is 0 or 1. + +The second row is added only when the resulting rank is at most three. +The code uses an original monomial representative. It does not use a +reduced row as a new bounded generator. + +For r at most three, every r by r minor of these original rows has +absolute value at most floor(r^(r/2)), hence at most five. Cramer's rule +therefore writes each nonzero RREF entry as n/d with |n| at most five +and 1 <= d <= 5. Two such reduced fractions with the same image in +F_101 are equal: their cross difference has absolute value at most +50, which is less than 101. This proves the rational reconstruction +used for primitive-parity pruning. + +After reconstruction, the least common multiple of all denominators +is at most 60. Each integer numerator after this multiplication has +absolute value at most 300. Divide their greatest common divisor and +reduce modulo two. This is a primitive integer row of the rational +relation space. It lies in the saturated integer kernel of any actual +frame realization. The off-diagonal derivative rows and the returned +diagonal derivative row lie in that same kernel modulo two. Its binary +dimension is at most three. This proves the parity rejection rule. + +Every finite-field rank comparison agrees with the rational comparison. +A state has at most three original bounded generators. Testing a new +collision, a zero paid frame, or a returned target adds at most one +nonunit bounded row. The relevant minors have at most four nonunit +rows. Their absolute values are at most 16 by Hadamard's inequality. +Testing whether an active target lies in a two-frame span also adds +two coordinate unit rows. Expand a determinant along these unit rows; +the remaining minor still has at most four nonunit bounded rows. +Thus no nonzero minor relevant to a decision vanishes modulo 101. + +Two cached states have the same rational row space if and only if they +have the same row space over F_101. Each has rank at most three. If their +union has larger rank, at most four rows witness that fact. Those rows +are again original bounded generators, so the same minor bound applies. + +The code's GeneralBasis has capacity for six rows: three state rows, +two coordinate unit rows, and one target row. Forward elimination with +pivots in increasing order is sufficient for its rank tests. RREF is +used for cached states. + +The F101 source and these bounds passed an independent source audit by +the gaussian_escape agent. A separate integer engine checked the same +binary word files. The two engines found the same 538 rank-three word +IDs with diagonal terminals and the same terminal count for each ID. +Both found no accepted terminal. They also checked all 27156 rank-two +canonical orders and found no diagonal terminal. + +Seven additional controls check the formal polynomial search core. +They include acceptance after a required collision and acceptance after +a returned-target relation, as well as targeted rejection cases. These +are polynomial fixtures, not admissible paid-call circuit constructions. +Their separate scope is stated in dirty_f101_controls.py. diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_ancilla.py b/research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_ancilla.py new file mode 100644 index 0000000000..2cc796fe7c --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_ancilla.py @@ -0,0 +1,169 @@ +"""Check two exact eleven-factor words from three binary basis layers.""" +from fractions import Fraction +from functools import lru_cache +from itertools import combinations +import json,time,sys +from pathlib import Path + +W=4; E=8; MAXREL=3 +ID=sum(1<<(i*W+i) for i in range(W)) +OFF=sum(1<<(i*W+j) for i in range(W) for j in range(W) if i!=j) +BITS=[tuple((s>>i)&1 for i in range(E)) for s in range(1<>i)&1)*((y>>j)&1)<<(W*i+j) for i in range(W) for j in range(W)) + +def times_projection(m,x,y): + mx=sum((((m>>(W*i))&15)&x).bit_count()%2<>bit)&1)<>bit&1] + seen=set();stats={'nodes':0,'terminals':0,'low_rank_targets':0,'zero_frame_branches':0,'parity_branches':0,'terminal_relations':[],'wrong_zero_count':0} + found=[] + def rec(state): + stats['nodes']+=1 + if state in seen:return False + seen.add(state) + if gf2_rank(first_order+[primitive_parity(r) for r in state])>MAXREL: + stats['parity_branches']+=1;return False + grouped={} + for s,c in poly: + key=rep(state,BITS[s]);grouped[key]=grouped.get(key,0)^c + terms=[(a,c) for a,c in grouped.items() if c] + offending=[(a,c&OFF) for a,c in terms if c&OFF] + if not offending: + stats['terminals']+=1 + stats['terminal_relations'].append([[str(x) for x in r] for r in state]) + targets=[] + for i in range(W): + tt=[v for v,c in terms if c>>(W*i+i)&1] + assert len(tt)==1,(state,tt) + targets.append(tt[0]) + for ancilla in range(W): + nxt=state if not any(targets[ancilla]) else add(state,targets[ancilla]) + if nxt is None or len(nxt)>MAXREL:continue + if gf2_rank(first_order+[primitive_parity(r) for r in nxt])>MAXREL:continue + low=False + for i,t in enumerate(targets): + if i==ancilla:continue + if any(not any(rep(rref(nxt+(UNIT[a],UNIT[b])),t)) for a,b in combinations(range(E),2)): + low=True;break + if low: + stats['low_rank_targets']+=1;continue + found.append({'ancilla':ancilla,'relations':[[str(x) for x in r] for r in nxt],'targets':[[str(x) for x in rep(nxt,t)] for t in targets]}) + return True + return False + if len(state)>=MAXREL:return False + best=None + for bit in range(W*W): + if not OFF>>bit&1:continue + tt=[v for v,c in offending if c>>bit&1] + if tt and (best is None or len(tt)>i)&1)<>j&1 and not pred[j]&todo),key=lambda j:(word[j],j)) + out.append(word[i]);todo^=1<b.bit_length(): + if v>>(b.bit_length()-1)&1:v^=b + return v + +def parity_possible(word): + fo=[sum(((core.outer(x,y)>>bit)&1)<>bit&1] + bs={} + for v in fo: + while v: + k=v.bit_length()-1 + if k in bs:v^=bs[k] + else:bs[k]=v;break + if len(bs)<3:return True + if len(bs)>3:return False + basis=[bs[k] for k in sorted(bs,reverse=True)] + grouped={} + for s,c in core.polynomial(word): + key=binary_reduce(s,basis);grouped[key]=grouped.get(key,0)^c + return not any(c&core.OFF for c in grouped.values()) + +if __name__=='__main__': + started=time.time();families=[];out=[];totals={'raw_distance_classes':0,'irreducible_classes':0,'raw_orders':0,'canonical_orders':0,'parity_rejected':0,'searched_orders':0,'nodes':0,'terminals':0,'candidates':0} + for v in combinations_with_replacement(range(8),8): + c=tuple(v.count(i) for i in range(8)) + if c!=min(transform_counts(c,p) for p in PERMS):continue + if not core.valid_distance([(P[j],P[j]) for j in v]):continue + totals['raw_distance_classes']+=1 + if not irreducible(c):continue + families.append(c) + totals['irreducible_classes']=len(families) + print(json.dumps({'families':families}),flush=True) + for fi,c in enumerate(families): + stabilizer=[p for p in PERMS if transform_counts(c,p)==c] + seen=set();fstats={'counts':c,'raw':0,'canonical':0,'parity_rejected':0,'searched':0,'nodes':0,'terminals':0,'candidates':[]} + for raw in words(c): + fstats['raw']+=1 + if normal(raw)!=raw:continue + w=canonical(raw,stabilizer) + if w in seen:continue + seen.add(w);fstats['canonical']+=1 + word=[(P[j],P[j]) for j in w] + if not parity_possible(word):fstats['parity_rejected']+=1;continue + result=core.solve(word);fstats['searched']+=1 + fstats['nodes']+=result['stats']['nodes'];fstats['terminals']+=result['stats']['terminals'] + if result['candidate']:fstats['candidates'].append(result) + core.rref.cache_clear();core.rep.cache_clear();core.add.cache_clear() + out.append(fstats) + for a,b in [('raw_orders','raw'),('canonical_orders','canonical'),('parity_rejected','parity_rejected'),('searched_orders','searched'),('nodes','nodes'),('terminals','terminals')]:totals[a]+=fstats[b] + totals['candidates']+=len(fstats['candidates']) + print(json.dumps({'family':fi,'stats':fstats,'seconds':time.time()-started}),flush=True) + Path(__file__).with_suffix('.json').write_text(json.dumps({'totals':totals,'families':out,'seconds':time.time()-started},indent=2)+'\n') diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_rank2.py b/research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_rank2.py new file mode 100644 index 0000000000..c365361256 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/dirty_rank2.py @@ -0,0 +1,49 @@ +"""Prune all rank-two off-pattern pools for an eight-call dirty word.""" +import json,math,time +from pathlib import Path +from itertools import combinations_with_replacement +import dirty_ancilla as core +from dirty_h_alphabet import SUBSPACES + +def possible_ancillas(word): + possible=set(range(4)) + for side in (0,1): + for r in range(1,16): + if sum((r&xy[side]).bit_count()%2 for xy in word)<3: + if r.bit_count()!=1:return set() + possible&={r.bit_length()-1} + return possible + +def irreducible(word): + for vs in SUBSPACES: + if all(x in vs or not any((y&v).bit_count()%2 for v in vs) for x,y in word):return False + return True + +def pattern_rows(word,anc=None): + mask=core.OFF | (0 if anc is None else 1<<(anc*5)) + return [sum(((core.outer(x,y)>>bit)&1)<>bit&1] + +if __name__=='__main__': + pools=json.loads(Path('work/four-register/independent/off-pattern-spaces.json').read_text())['levels'][1]['representatives'] + out=[];stats={'pool_classes':len(pools),'multisets':0,'distance':0,'irreducible':0,'augmented':0,'raw_order_bound':0} + start=time.time() + for pi,pool in enumerate(pools): + ns=[tuple(v) for v in pool['projectors']] + for choice in combinations_with_replacement(range(len(ns)),8): + stats['multisets']+=1;word=[ns[j] for j in choice] + if core.gf2_rank(pattern_rows(word))!=2:continue + aa=possible_ancillas(word) + if not aa:continue + stats['distance']+=1 + if not irreducible(word):continue + stats['irreducible']+=1 + aa=[a for a in aa if core.gf2_rank(pattern_rows(word,a))<=3] + if not aa:continue + stats['augmented']+=1 + counts=[choice.count(i) for i in range(len(ns))] + orders=math.factorial(8)//math.prod(math.factorial(c) for c in counts) + stats['raw_order_bound']+=orders + out.append({'pool':pi,'projectors':ns,'counts':counts,'ancillas':aa,'raw_orders':orders}) + result={'stats':stats,'families':out,'seconds':time.time()-start} + Path(__file__).with_suffix('.json').write_text(json.dumps(result,indent=2)+'\n') + print(json.dumps({'stats':stats,'seconds':result['seconds']}),flush=True) diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/DIRTY-AUDIT.txt b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/DIRTY-AUDIT.txt new file mode 100644 index 0000000000..2e32dd87a3 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/DIRTY-AUDIT.txt @@ -0,0 +1,323 @@ +Three active targets and one returned register: independent audit + +Model and relation bound + +The exact target is diag([C1],[C2],[C3],1), up to a permutation of +coordinates. The C_i are invertible lower-triangular rational 3-by-3 +frames. The fourth input is arbitrary and must be returned unchanged. +The paid frames are nonzero rational rank-one matrices. There are eight +binary rank-one idempotent scalar calls. + +The span-four lemma continues to hold with zero targets: replace the +number of scalar registers in each projected target-rank count by the +number of active targets. Choose an active invertible target when the +proof forms target ratios. Zero targets stay zero in each block; active +targets have invertible diagonal blocks. Thus frame span at most four +requires at least nine calls. Any eight-call circuit needs frame span +at least five and rational relation dimension at most three. + +A candidate must be scalar irreducible. Let V be a common binary invariant subspace. The product preserves +V after extension to the group algebra. Distinct group monomials are +linearly independent. Thus each coordinate projection onto one equal- +character space preserves V. This includes the zero character of the +returned register, which differs from every active target character. +V is the direct sum of its intersections with those character spaces. +Choose a basis in each equal-character space adapted to V. This keeps +the endpoint diagonal and puts every paid scalar projector in block +upper-triangular form. This argument does not assume that V is a +coordinate subspace or that the three active characters are distinct. +A rank-one idempotent in this block form has exactly one nonzero +diagonal block, and that block is a rank-one idempotent. Thus the calls +partition between the two diagonal blocks. A block with one active +target needs at least three calls by rank subadditivity. Two active +targets need at least six, even with returned coordinates: at at most +five calls, span at most four is covered by the preceding lemma; the +only other case has five independent frames. No distinct subset sums +then collide, and differentiation of the diagonal polynomial at one +forces all scalar projectors to be coordinate projectors. Each active +target still needs three frames. A proper block with all three active +targets has size three and is covered by PR468. Every split therefore +needs at least nine calls. These arguments are also in DIRTY-MODEL.txt +and were reviewed separately by bit8_algebra and the root agent. + +Visible scalar distance is a rational-rank argument + +Fix a possible returned coordinate a. For a binary row v, let J be +the calls with v*x_j=1. If a rational functional kills all frames in +J, each projected factor fixes v. The projected target can fix v only +if it kills each active target selected by v. Thus each such target is +in the rational span of the frames in J. Fewer than three rank-one +frames cannot span an invertible 3-by-3 target. Every nonzero v other +than e_a must therefore select at least three calls. The argument for +y_j and columns is the dual statement. It uses no reduction of address +frames modulo two. + +The code correctly takes the union over all four possible returned +roles. A row or column of weight greater than one with fewer than three +visible calls rejects every role. A failing singleton leaves only its +own role. Two different failing singletons reject every role. + +The exact returned-register condition + +At a rational diagonal terminal, every diagonal entry is one monomial, +by the determinant/unit argument in PROOF-AUDIT.txt. A returned entry +must equal [0]=1 in the group algebra of rational frames. This requires +its exponent to be exactly zero, not merely even or zero modulo two. + +dirty_ancilla.py implements this correctly: for each possible returned +coordinate, it adds that exponent as an exact rational relation using +Fraction RREF. It rejects zero paid frames and relation rank above +three. It then checks every active target against the exact rational +span of each pair of paid-frame units. This test does not use a short +representative in a binary quotient. Each rejected active target is +therefore a rational sum of at most two rank-one matrices. + +Adding a relation after reaching a diagonal terminal cannot create an +off-diagonal term. There is no missing collision branch at this step. +Trying every coordinate covers every possible returned role. + +The finite binary quotient is only a necessary identity check + +Let K be the actual saturated integer relation lattice in Z^8. Its +modulo-two image has dimension at most three. The off-diagonal +augmentation derivative rows belong to this image. The returned +diagonal derivative row belongs to it too, since the derivative of 1 +is zero. The active diagonal rows need not belong to it. + +If the selected derivative rows have rank greater than three, the +candidate is impossible. If their rank is exactly three, their span +is the full modulo-two image of K. Map the formal polynomial to the +finite group algebra of F2^8 modulo that span. Every off-diagonal +entry must still vanish. If the returned diagonal is included, it must +equal one, and the code subtracts that constant before checking it. + +The H-alphabet filter uses only off-diagonal rows. The later rank-two +and generic rank-three filters also use a candidate returned diagonal. +When the selected rank is below three, the rank-two filter retains the +word because an additional unknown relation may still occur. It takes +the union of the results for all admissible returned coordinates. + +This check is sound because every valid rational identity maps to the +finite quotient identity. The converse is false. In particular, a short +binary representative of an active target does not imply a rational +rank bound. None of the inspected filters makes that false inference. + +Independent H-alphabet census + +The alphabet consists of four coordinate projectors and the four +projectors from H=I+J_4. An independent script enumerates multiplicities +as weak compositions, not as the producer's combinations with +replacement. It checks irreducibility by closing the orbit span of each +nonzero vector, instead of enumerating invariant subspaces. + +It groups orders by their subsequences on every pair of noncommuting +letters. These dependence signatures identify trace classes. An +independent explicit orbit calculation then applies coordinate +permutations and reversal. This does not reuse the producer's greedy +trace-normalization procedure to establish class coverage. + +For each class, direct dense matrix multiplication in the finite group +algebra checks the binary quotient condition. This differs from the +producer's formal polynomial expansion and remainder grouping. + +The complete independent census agrees: + + 20 distance-compatible multiplicity classes; + 14 scalar-irreducible classes; + 216720 distinct raw orders within those representative classes; + 2771 classes after the valid order symmetries; + 1115 words rejected by the binary quotient identity. + +The other 1656 representative words use the separately audited rational +collision solver. Its saved result has zero candidates. The finite +census does not claim an independent full rational collision replay. + +Reversal remains valid for nonsymmetric projectors + +For any idempotent N, D_N(z)^(-1)=D_N(z^(-1)). Invert a valid diagonal +word, then apply the address-group map A -> -A. This reverses factor +order and preserves the original diagonal target. Thus generic order +searches may use reversal without transposing the individual N_j. +Commuting adjacent factors is also valid for every assignment of frames. + +Independent coverage of the generic off-pattern catalogue + +There are 120 binary rank-one idempotents in four registers. Their +nonzero off-diagonal parts have 104 distinct patterns. The derivative +bound implies that the actual off-pattern span has dimension at most +three: the row rank and column rank of the derivative matrix agree. +Its basis can be chosen from the actual patterns. Thus direct spans of +all one-, two-, and three-element pattern subsets cover every case. + +Each catalogue pool contains every projector with pattern in its space, +including all four coordinate projectors. If that full pool is +reducible, every subset is reducible. A subspace invariant under all +coordinate projectors must be a coordinate subspace. Hence the full +pool is irreducible exactly when its union support graph is strongly +connected. It is valid to discard non-strong spaces. Individual +multisets in a strong pool still need their own irreducibility check. + +The independent generator uses direct pattern combinations, a compact +twelve-bit encoding, Boolean matrix transitive closure, and explicit +coordinate-permutation orbits. It reproduces every representative and +every complete projector pool in the producer's catalogue: + + rank one: 104 spaces, 0 strong spaces, 0 classes; + rank two: 4964 spaces, 634 strong spaces, 45 classes; + rank three:140281 spaces, 63567 strong spaces,2846 classes. + +The exact numbers of eight-call multisets over the full pools are +sum_pool binomial(pool_size+7,8): 61347 for rank two and 11210628 for +rank three. The catalogue receipt records independent canonical hashes. + +Review of the generic C++ multiset filter + +rank3_multisets.cpp enumerates every nonnegative count vector with sum +eight in each pool. It requires actual off-pattern rank three, applies +the visible-distance condition, and tries every possible returned role. +For each role it appends the actual N_aa bit to the off-pattern vector +and requires augmented binary rank at most three. All of these are +necessary conditions. Multiplicity does not change the column-span +rank, but the distance count correctly includes multiplicities. + +Its invariant-subspace check closes the orbit span of each nonzero +vector under the used projectors. A fixed proper orbit span is an +invariant subspace. If a proper invariant subspace exists, an orbit +started inside it cannot reach the whole space. The check is exact. + +The integer fields called off must be a linear coordinate map for the +catalogue's off-pattern space. The separate input-binding check verifies +all projector labels and all pairwise XOR identities for these labels. +The source review does not alone certify an arbitrary unbound input file. + +Independent generic multiset and order replays + +A second C++ census enumerates supports first and then positive +multiplicities. It computes binary rank from the full matrix bits and +checks all 65 proper nonzero binary subspaces directly. This differs +from the producer's count-vector recursion, compressed space labels, +and invariant orbit closures. It examines all 11210628 rank-three +pool multisets and returns exactly the same 4020 families and returned- +role masks. A separate binding script checks every pool and label, +every family count vector, every text order, and every binary record. + +A second C++ order check enumerates all 41706000 raw permutations with +next_permutation. It checks trace normality only after a full order is +formed. The producer instead removes non-normal prefixes. The second +check computes commutation by full matrix multiplication. It computes +the quotient by explicit span and complement sets, then uses one +32-bit group-ring vector for each scalar matrix entry. The producer +uses packed matrix coefficients indexed by quotient elements. + +The independent replay gives these exact counts: + + 4020 multiset families; + 41706000 raw orders; + 7121514 commutation normal forms; + 3560923 representatives after reversal; + 1901600 finite-quotient survivors. + +Every retained matrix word and returned-role mask agrees, in order, +with the shared binary input to both collision engines. That input has +34228800 bytes and SHA-256 +97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911. +The rank-three shared front end therefore has a complete independent +replay. + +The same support-first census independently checks all 61347 rank-two +pool multisets and returns the same 103 retained families. A separate +Python replay enumerates all 831600 raw orders by choosing positions +for each repeated letter. It groups them by their subsequences on +noncommuting letter pairs, then takes reversal orbits. Thus it does +not use the producer's greedy normal form or prefix pruning. It gets +54294 trace classes and 27156 reversal representatives. Every matrix +word and returned-role mask agrees with rank2-words.bin before any +finite-quotient pruning. That file has 488808 bytes and SHA-256 +f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee. + +Exact collision search + +At a state with rational relation space R, reduce the formal polynomial +modulo R. Choose a term in a nonzero off-diagonal entry. In any valid +extension of R, that term must collide with another surviving term in +the same entry. Branch on every such difference. Terms already removed +in pairs stay removed under every extension. Thus no necessary branch +is lost. Each new relation increases rank, and rank is at most three. +A diagonal terminal can add the exact returned exponent as a relation. +Adding this relation cannot create an off-diagonal entry. + +The determinant of each paid factor is its frame monomial. A diagonal +terminal therefore has monomial product determinant. The frame group +is finitely generated and torsion-free, so its group algebra is a +Laurent polynomial ring over F2. Its units are monomials. Each diagonal +entry is consequently a single monomial. The exact rational pair-span +test rejects a target in the span of two paid rank-one frames. This is +a necessary rank-three condition, not a sufficient construction test. + +Two engines complete the rank-three input: the primitive-integer +engine and the finite-field engine with exact rational reconstruction. +Both process all 1901600 words, return the same 538 terminal word IDs, +and have zero surviving target candidates. A Fraction implementation +also replays all 538 terminal words and rejects all of them. The rank- +two primitive-integer run processes all 27156 canonical words before +any finite-quotient pruning, and has zero diagonal terminals. + +Why reduction modulo 101 is exact here + +Every state has at most three independent original relation rows. +Each original row is a difference of two subset indicators, or the +returned subset indicator. Its entries are in {-1,0,1}. A rank or +membership test adds at most one further such row. Pair-span tests +also append two coordinate unit rows; expansion along those rows +removes them from the relevant minors. Every remaining minor uses at +most four bounded nonunit rows. Hadamard's bound gives absolute value +at most 16, which is less than 101. A nonzero rational rank witness +therefore cannot vanish modulo 101. + +Each completed state RREF entry is a ratio of minors of order at most +three. Numerator and denominator have absolute value at most five. +Two such reduced fractions cannot have the same residue modulo 101: +their cross difference has absolute value at most 50. Thus the code's +bounded rational reconstruction is unique. The parity prune uses the +primitive integer lift of this rational row, and hence uses a member +of the actual saturated integer kernel. It does not assume that a +chosen set of nonprimitive integral generators is already saturated. + +Bounds for the primitive-integer implementation + +Completed primitive state rows have entries of absolute value at most +five, by the same minor bound. Their positive pivots are at most five. +A raw bounded row reduced against three such rows has intermediate +entries at most 1000. The separate pair-span helper can append two +unit rows: a conservative bound is 1000 for the first reduced row, +2000000 for the second, and 8000000000000 while reducing the target. +All are below the signed 64-bit limit. The common quotient denominator +is at most lcm(1,2,3,4,5)=60, and quotient-key entries are at most 960. +The reviewed arithmetic does not depend on signed overflow. + +Scope of completion + +The analytic reductions, the generic off-pattern catalogue, the full +rank-three multiset and order front end, and the exact collision tests +have passed independent mathematical review. The finite-field test +has an explicit rational-equivalence proof; it is not a probabilistic +prime test. The two final engines use different arithmetic but share +an input file, whose complete generation has a separate independent replay for both +rank two and rank three. Both the catalogue and the role union are +covered by these replays. + +Subject to the proved span-four and three-register lemmas in PR468, +the exact eight-call classification excludes three active invertible +lower-triangular rational 3-by-3 targets with one arbitrary returned +register. Any positive shorter word can be padded to eight calls by +splitting a nonzero rank-one frame A into two consecutive calls with +frame A/2 and the same projector. Hence eight-call impossibility also +excludes shorter words. Nine coordinate calls realize the three +identity 3-by-3 targets and return the fourth register. The minimum +number of calls in this specified model is therefore nine. + +This conclusion concerns four scalar registers, rank-one rational +paid frames, binary rank-one idempotent scalar projectors, and a +formal identity for all inputs. It is not a lower bound for every bit +construction in the repository. It gives no direct increase in kappa. +This audit is mathematical and computational; it is not a Lean proof. diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/PROOF-AUDIT.txt b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/PROOF-AUDIT.txt new file mode 100644 index 0000000000..d9e536d8d5 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/PROOF-AUDIT.txt @@ -0,0 +1,173 @@ +Independent audit of the eleven-call H/I/H exclusion + +Scope + +There are four scalar registers over F2. Each paid call has a nonzero +rational rank-one 3-by-3 address frame A_j and a binary rank-one +idempotent N_j. The required output is diagonal, with four invertible +lower-triangular rational 3-by-3 target frames. There are eleven calls. + +The checked words use three complete binary basis layers H/I/H, where +H=I+J_4, with one of the twelve factors omitted. This audit does not +exclude every eleven-call four-register word. It does not establish a +construction, a new kappa, or a general four-register lower bound. + +1. Bound on relation rank + +The span-four lemma in PR468 states, for any number W of scalar +registers, that address-frame span at most four requires at least 3W +calls for invertible lower-triangular targets in address dimension three. +For W=4 and eleven calls, the frame span therefore has dimension at +least five. The rational kernel of the map + + Q^11 -> Mat_3(Q), e_j -> A_j + +has dimension at most six. The code's MAXREL=6 uses that lemma. +The lower-triangular hypothesis is essential to this reduction. +The audit read that proof in the PR468 worktree at commit 07a78bf. +Its two cases do not use W=3. In the full-support case every paid +frame is on one of four rank-one lines; invertibility requires at least +three nonzero line coefficients per target. In the other case, the +diagonal blocks have sizes at most two. The inherited common rational +flag gives the dimension-two bound 2W; a one-dimensional block needs W. +The assigned calls are disjoint and the block sizes sum to three. +Thus the same written proof gives 3W when W=4. + +2. Polynomial reconstruction + +Each call is I+(z_j+1)N_j over F2. Since every variable occurs in one +factor, each matrix entry is multilinear. The source forms its exact +polynomial by multiplying a current coefficient matrix on the right by +N_j or I+N_j. The stored matrix uses row-major binary entries. + +The independent checker uses a different construction. It evaluates the +eleven-factor dense 4-by-4 product at all 2^11 Boolean points, then uses +Boolean Mobius inversion to recover every polynomial coefficient. +Both omission types agree with the source coefficients, with 36 nonzero +support terms in each case. The two word types thus receive +4096 independently formed dense matrix evaluations. + +3. Saturation and the parity prune + +Let G be the additive group generated by the actual rational frames. +It is a finitely generated torsion-free abelian group. Let + + K = ker(Z^11 -> G). + +Then K is saturated: Z^11/K is free abelian. In particular, reduction +modulo two embeds K/2K into F2^11, with image of dimension rank(K)<=6. +One must use this group G, not an arbitrary denominator-cleared ambient +integer matrix whose reduction modulo two can lose rank. + +Apply augmentation degree one to the group-algebra identity. Since the +target is diagonal, for each off-diagonal scalar position (a,b), + + sum_j (N_j)_(a,b) [A_j] = 0 in G/2G. + +Thus the binary coefficient vector belongs to the mod-two image of K. +These are exactly the code's twelve first_order vectors. + +Every current rational collision relation lies in the actual rational +kernel along a branch that can describe a valid circuit. Clear its +denominators and divide the integer row by its gcd. The resulting +primitive integer row still lies in K. Its parity is also in the same +rank-at-most-six space. If the combined binary rank exceeds six, that +branch cannot contain a valid circuit. + +The current RREF rows need not generate the whole saturated lattice. +This causes no soundness problem: their primitive rows are a subset +of K. An incomplete subset can only weaken this prune. The proof does +not identify their integer span with K. + +4. Exact quotient and complete branching + +Let R be the actual rational frame kernel and L the currently imposed +relation space. Along a compatible branch L is a subspace of R. +Grouping terms by their RREF remainder groups exactly equal images in +Q^11/L. The independent checker confirms this quotient comparison by +integer, fraction-free rank calculations on separate generated rows. + +If an off-diagonal entry is still nonzero, choose one surviving support +u in it. In a final valid quotient its contribution must cancel with +another surviving support v from the same scalar entry. Otherwise its +coefficient remains one. Hence u-v belongs to R. The search branches +over every such v. The chosen supports differ modulo L, so this new +relation increases dim(L). Recursion reaches depth at most six. + +If a unit coordinate e_j enters L, then A_j=0 in every further quotient. +That branch violates the nonzero paid-frame hypothesis. If dim(L)=6 +and an off-diagonal entry remains, no further relation can occur in a +compatible rank-at-most-six kernel. Both stopping rules are sound. + +The cached state is canonical rational RREF. Repeated states have the +same future possibilities. Reusing a completed rejection is sound. +There is no cycle: each recursive collision increases relation rank. + +5. Diagonal terminals and the rank-two obstruction + +For a rank-one idempotent, det(I+(z+1)N)=z. Therefore the determinant +of the product in every torsion-free quotient is a monomial. A +diagonal terminal has diagonal entries whose product is a unit. Each +diagonal entry is consequently a unit in the Laurent polynomial ring +F2[G_L], and each such unit is one monomial. This justifies the code's +assertion that every diagonal has exactly one support. + +If target support t belongs to L+span_Q(e_i,e_j), then in every further +physical realization its target frame belongs to span_Q(A_i,A_j). +A sum of two rank-one rational matrices has rank at most two. It cannot +equal an invertible 3-by-3 target. The pair-span rejection is therefore +sound and remains sound after additional relations. Pairs also cover +the zero- or one-frame cases by giving a coefficient value zero. + +6. Independent terminal identities + +For an omitted outer factor a_1, the surviving terminal relations are + + b_1=b_2=b_3=b_4, + a_i+c_i=c_1 for i=2,3,4. + +All four targets equal b_1+c_1. The checker substitutes these relations +directly into the independently reconstructed polynomial in a free +five-dimensional rational address space. Its four diagonal targets +are exactly that sum of two paid frames. + +For an omitted middle factor b_1, the terminal relations are + + a_1=a_2=a_3=a_4, + c_1=c_2=c_3=c_4. + +The first target is a_1+c_1, and the others are a_1+b_i+c_1. The same +direct independent substitution verifies the full matrix identity. +The first target again has rank at most two. + +7. Symmetry and limits of coverage + +The four projectors in each complete layer are mutually orthogonal, +so their order within that layer does not matter. A simultaneous +permutation of the four scalar coordinates permutes the omitted +coordinate and preserves H=I+J_4. All outer omissions are equivalent +under this symmetry and word reversal/transposition. Middle omissions +are also equivalent. Thus two cases cover one omitted factor from +the twelve-factor H/I/H template. + +This argument does not assert that every eleven-call scalar word is +conjugate to this template. It does not silently include templates +with multiple omitted factors or other interleaved orders. + +Verification boundary + +The exhaustive counts are from the source engine. This audit does not +claim a second exhaustive implementation. It checks the mathematics +of the complete search, reconstructs both full input polynomials by +an independent method, checks quotient/pair-span operations through +independent integer rank calculations, and directly verifies both +terminal identities. See RESULT.json for actual finite check counts. + +The source increments stats.nodes before its repeated-state lookup. +Therefore 125529 and 120694 count recursive calls, not necessarily +distinct relation states. The saved output does not report len(seen). +This affects the label on a search count, not the mathematical result. + +No correctness bug was found in the scoped search logic. No source or +public branch was changed by this audit. The source result remains +conditional on the stated span-four lemma and model hypotheses. diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_input_binding.py b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_input_binding.py new file mode 100644 index 0000000000..0dc5af5e3f --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_input_binding.py @@ -0,0 +1,73 @@ +"""Bind the scalar catalogue, multiset rows, word stream, and binary input.""" +from pathlib import Path +import hashlib +import json +import struct + +BASE = Path(__file__).resolve().parents[1] +ROOT = BASE / 'independent' + + +def matrix(x, y): + return sum(((x >> i) & 1) * ((y >> j) & 1) << (4 * i + j) + for i in range(4) for j in range(4)) + + +def main(): + pools = json.loads((ROOT / 'off-pattern-spaces.json').read_text())['levels'][2]['representatives'] + tokens = iter(map(int, (ROOT / 'rank3-pools.txt').read_text().split())) + assert next(tokens) == len(pools) + for pool in pools: + expected = pool['projectors'] + assert next(tokens) == len(expected) + space = pool['space'] + for i in range(8): + for j in range(8): + assert space[i] ^ space[j] == space[i ^ j] + for x, y in expected: + assert (next(tokens), next(tokens), next(tokens)) == \ + (x, y, space.index(matrix(x, y) & 0x7bde)) + assert next(tokens, None) is None + + original = [json.loads(line) for line in (ROOT / 'rank3-multisets.jsonl').open()] + independent = [json.loads(line) for line in Path(__file__).with_name('rank3-multisets.jsonl').open()] + key = lambda row: (row['class'], tuple(row['counts']), row['possible_ancilla']) + assert len(set(map(key, original))) == len(original) + assert set(map(key, original)) == set(map(key, independent)) + tokens = iter(map(int, (ROOT / 'rank3-word-input.txt').read_text().split())) + assert next(tokens) == len(original) + for record in original: + ns = pools[record['class']]['projectors'] + assert next(tokens) == len(ns) + assert next(tokens) == record['possible_ancilla'] + for (x, y), count in zip(ns, record['counts']): + assert (next(tokens), next(tokens), next(tokens)) == (x, y, count) + assert next(tokens, None) is None + + records = 0 + sha = hashlib.sha256() + with (ROOT / 'rank3-words.bin').open('rb') as binary: + for line in (ROOT / 'rank3-parity-survivors.jsonl').open(): + row = json.loads(line) + family = original[row['family']] + ns = pools[family['class']]['projectors'] + order = row['order'] + assert len(order) == 8 + assert [order.count(i) for i in range(len(ns))] == family['counts'] + roles = row['ancilla_mask'] + assert roles and not (roles & ~family['possible_ancilla']) + expected = struct.pack('<9H', *(matrix(*ns[i]) for i in order), roles) + assert binary.read(18) == expected + sha.update(expected) + records += 1 + assert not binary.read(1) + result = dict(status='PASS_CATALOGUE_MULTISET_WORD_BINARY_BINDING', + pool_classes=len(pools), multiset_rows=len(original), + independent_multiset_rows=len(independent), binary_records=records, + binary_bytes=18*records, binary_sha256=sha.hexdigest()) + Path(__file__).with_name('INPUT-BINDING-RESULT.json').write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps(result)) + + +if __name__ == '__main__': + main() diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_off_catalogue.py b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_off_catalogue.py new file mode 100644 index 0000000000..5270c29212 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_off_catalogue.py @@ -0,0 +1,90 @@ +"""Rebuild off-pattern spaces from direct generator combinations.""" +from itertools import combinations, permutations +from pathlib import Path +from math import comb +import hashlib +import json + +BASE = Path(__file__).resolve().parents[1] +OFF_POSITIONS = [(i, j) for i in range(4) for j in range(4) if i != j] + + +def span(generators): + out = {0} + for value in generators: + out |= {x ^ value for x in tuple(out)} + return tuple(sorted(out)) + + +def matrix(value): + return sum(((value >> k) & 1) << (4 * i + j) + for k, (i, j) in enumerate(OFF_POSITIONS)) + + +def connected(space): + edges = 0 + for value in space: + edges |= value + # Boolean matrix closure, independent of the source's vertex scans. + paths = [[i == j for j in range(4)] for i in range(4)] + for k, (i, j) in enumerate(OFF_POSITIONS): + paths[i][j] = bool(edges >> k & 1) + for k in range(4): + for i in range(4): + for j in range(4): + paths[i][j] |= paths[i][k] and paths[k][j] + return all(all(row) for row in paths) + + +def main(): + source = json.loads((BASE / 'independent/off-pattern-spaces.json').read_text()) + projectors = [] + for x in range(1, 16): + for y in range(1, 16): + if sum(((x >> i) & 1) * ((y >> i) & 1) for i in range(4)) % 2: + off = sum((((x >> i) & 1) * ((y >> j) & 1)) << k + for k, (i, j) in enumerate(OFF_POSITIONS)) + projectors.append((x, y, off)) + patterns = sorted({off for x, y, off in projectors} - {0}) + maps = [] + for perm in permutations(range(4)): + destinations = [OFF_POSITIONS.index((perm[i], perm[j])) + for i, j in OFF_POSITIONS] + maps.append([sum(((value >> k) & 1) << destinations[k] for k in range(12)) + for value in range(4096)]) + rows = [] + for dimension in (1, 2, 3): + # Direct combinations differ from the producer's iterative closure. + spaces = {space for basis in combinations(patterns, dimension) + if len(space := span(basis)) == 1 << dimension} + strong = {s for s in spaces if connected(s)} + unseen = set(strong) + representatives = set() + while unseen: + chosen = next(iter(unseen)) + orbit = {tuple(sorted(mapping[v] for v in chosen)) for mapping in maps} + assert orbit <= strong + unseen -= orbit + representative = min(tuple(sorted(matrix(v) for v in s)) for s in orbit) + representatives.add(representative) + recorded = source['levels'][dimension - 1] + assert len(spaces) == recorded['spaces'] + assert len(strong) == recorded['irreducible_spaces'] + expected = {tuple(r['space']): r['projectors'] for r in recorded['representatives']} + assert representatives == set(expected) + for space in representatives: + actual = [[x, y] for x, y, off in projectors if matrix(off) in space] + assert actual == expected[space] + payload = json.dumps(sorted(representatives), separators=(',', ':')).encode() + rows.append(dict(dimension=dimension, spaces=len(spaces), + strongly_connected_spaces=len(strong), classes=len(representatives), + representatives_sha256=hashlib.sha256(payload).hexdigest(), + eight_multisets=sum(comb(len(pool)+7, 8) for pool in expected.values()))) + result = dict(status='PASS_INDEPENDENT_OFF_PATTERN_CATALOGUE', projectors=len(projectors), + nonzero_off_patterns=len(patterns), levels=rows) + Path(__file__).with_name('OFF-CATALOGUE-RESULT.json').write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps(result)) + + +if __name__ == '__main__': + main() diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank2_orders.py b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank2_orders.py new file mode 100644 index 0000000000..478f08ebdf --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank2_orders.py @@ -0,0 +1,79 @@ +"""Check all rank-two orders with dependence signatures and reversal orbits.""" +from itertools import combinations +from pathlib import Path +import hashlib +import json +import struct + +HERE = Path(__file__).resolve().parent +BASE = HERE.parent + + +def words(counts): + def fill(letter, available, word): + if letter == len(counts): + yield tuple(word) + return + for places in combinations(available, counts[letter]): + next_word = word[:] + for position in places: + next_word[position] = letter + yield from fill(letter + 1, tuple(i for i in available if i not in places), next_word) + yield from fill(0, tuple(range(8)), [None] * 8) + + +def outer(x, y): + return tuple(((x >> i) & 1) * ((y >> j) & 1) for i in range(4) for j in range(4)) + + +def product(a, b): + return tuple(sum(a[4*i+k] * b[4*k+j] for k in range(4)) % 2 + for i in range(4) for j in range(4)) + + +def main(): + source = json.loads((BASE / 'dirty_rank2.json').read_text())['families'] + independent = [json.loads(line) for line in (HERE / 'rank2-multisets.jsonl').read_text().splitlines()] + expected = {(row['pool'], tuple(row['counts']), sum(1 << a for a in row['ancillas'])) for row in source} + actual = {(row['class'], tuple(row['counts']), row['possible_ancilla']) for row in independent} + assert len(expected) == len(source) == len(actual) == len(independent) == 103 + assert actual == expected + pools = json.loads((BASE / 'independent/off-pattern-spaces.json').read_text())['levels'][1]['representatives'] + raw = traces = representatives = 0 + binary = bytearray() + for family in source: + ns = family['projectors'] + assert ns == pools[family['pool']]['projectors'] + matrices = [outer(*xy) for xy in ns] + pairs = [(i,j) for i in range(len(ns)) for j in range(i+1,len(ns)) + if product(matrices[i], matrices[j]) != product(matrices[j], matrices[i])] + def signature(word): + return tuple(bytes(x for x in word if x == i or x == j) for i,j in pairs) + least = {} + for word in words(family['counts']): + raw += 1 + key = signature(word) + if key not in least or word < least[key]: + least[key] = word + traces += len(least) + retained = [] + for key, word in least.items(): + if word <= least[tuple(part[::-1] for part in key)]: + retained.append(word) + representatives += len(retained) + role = sum(1 << a for a in family['ancillas']) + for word in sorted(retained): + packed = [sum(bit << i for i,bit in enumerate(matrices[j])) for j in word] + binary += struct.pack('<9H', *packed, role) + saved = (BASE / 'independent/rank2-words.bin').read_bytes() + assert binary == saved + result = dict(status='PASS_INDEPENDENT_RANK2_FRONT_END', families=len(source), + raw_orders=raw, commutation_orders=traces, reversal_orders=representatives, + binary_word_and_role_stream_identical=True, + binary_bytes=len(binary), binary_sha256=hashlib.sha256(binary).hexdigest()) + (HERE / 'RANK2-FRONT-END-RESULT.json').write_text(json.dumps(result, indent=2)+'\n') + print(json.dumps(result)) + + +if __name__ == '__main__': + main() diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank3_multisets.cpp b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank3_multisets.cpp new file mode 100644 index 0000000000..6c85faddd4 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent-audit/check_rank3_multisets.cpp @@ -0,0 +1,126 @@ +// Enumerate supports first, then positive multiplicities, for an independent census. +#include +#include +#include +#include +#include +using namespace std; + +struct Gate { int x, y, matrix; }; +vector gates; +vector support, count_by_gate, spaces; +long long all_multisets=0, accepted=0; +int class_id, allowed_roles; + +int rank_binary(vector rows) { + int rank=0; + for(int col=0;col<16;++col) { + auto pivot=find_if(rows.begin()+rank,rows.end(),[&](int x){return (x>>col)&1;}); + if(pivot==rows.end())continue; + swap(rows[rank],*pivot); + for(int i=rank+1;i<(int)rows.size();++i) + if((rows[i]>>col)&1)rows[i]^=rows[rank]; + ++rank; + } + return rank; +} + +void emit_if_valid() { + int roles=0; + for(int a=0;a<4;++a)if((allowed_roles>>a)&1) { + bool valid=true; + for(int v=1;v<16 && valid;++v)if(v!=(1<=3 && yhits>=3; + } + if(valid)roles|=1<>v)&1) + for(int j:support) { + int image=__builtin_parity(unsigned(v&gates[j].y))?gates[j].x:0; + if(!((space>>image)&1)){invariant=false;break;} + } + if(invariant)return true; + } + return false; +} + +int choose(int n,int k) { + int out=1; + for(int i=1;i<=k;++i)out=out*(n-i+1)/i; + return out; +} + +int main(int argc,char**argv) { + if(argc!=2 && argc!=3)return 2; + int required_rank=argc==3?stoi(argv[2]):3; + if(required_rank!=2 && required_rank!=3)return 2; + set unique_spaces; + for(int a=1;a<16;++a)for(int b=0;b<16;++b)for(int c=0;c<16;++c) { + int mask=0; + for(int subset=0;subset<8;++subset) + mask|=1<<(((subset&1)?a:0)^((subset&2)?b:0)^((subset&4)?c:0)); + if(mask!=65535)unique_spaces.insert(mask); + } + spaces.assign(unique_spaces.begin(),unique_spaces.end()); + if(spaces.size()!=65)return 3; + ifstream input(argv[1]);int classes; + if(!(input>>classes))return 4; + for(class_id=0;class_id>n;gates.resize(n); + for(auto &gate:gates) { + int ignored;input>>gate.x>>gate.y>>ignored;gate.matrix=0; + for(int i=0;i<4;++i)if((gate.x>>i)&1)gate.matrix|=gate.y<<(4*i); + } + if(!input)return 5; + for(int selected=1;selected<(1<8)continue; + all_multisets+=choose(7,size-1); + support.clear(); + vector off; + for(int i=0;i>i)&1) { + support.push_back(i);off.push_back(gates[i].matrix&0x7bde); + } + if(rank_binary(off)!=required_rank)continue; + allowed_roles=0; + for(int a=0;a<4;++a) { + vector rows; + for(int i:support)rows.push_back(gates[i].matrix&(0x7bde|(1<<(5*a)))); + if(rank_binary(rows)<=3)allowed_roles|=1<>extra)return 6; + cerr<<"{\"classes\":"< +#include +#include +#include +#include +#include +#include +using namespace std; + +struct Gate { int x,y,m; vector steps; }; +vector gates; +bool commutes[16][16]; + +int scalar_product(int a,int b) { + int out=0; + for(int i=0;i<4;++i)for(int j=0;j<4;++j) { + int bit=0; + for(int k=0;k<4;++k)bit^=((a>>(4*i+k))&1)&((b>>(4*k+j))&1); + out|=bit<<(4*i+j); + } + return out; +} + +bool normal(const vector& word) { + for(int j=1;j<8;++j) + for(int i=j-1;i>=0 && commutes[word[i]][word[j]];--i) + if(word[i]>word[j])return false; + return true; +} + +vector least_trace(vector word) { + vector result; + while(!word.empty()) { + int chosen=0; + for(int i=1;i<(int)word.size();++i)if(word[i]& values,int x) { + if(find(values.begin(),values.end(),x)!=values.end())return; + int old=values.size(); + for(int i=0;i& sorted_word) { + vector relations{0}; + for(int i=0;i<4;++i)for(int j=0;j<4;++j)if(i!=j) { + int row=0; + for(int k=0;k<8;++k)row|=((gates[sorted_word[k]].m>>(4*i+j))&1)< full=relations, free; + for(int i=0;i<8;++i)if(find(full.begin(),full.end(),1<>i)&1)representative^=free[i]; + for(int r:relations)labels[r^representative]=g; + } + for(auto &gate:gates)gate.steps.clear(); + for(int k=0;k<8;++k)gates[sorted_word[k]].steps.push_back(labels[1<>1); + if(step&2)v=((v&0x33333333u)<<2)|((v&0xccccccccu)>>2); + if(step&4)v=((v&0x0f0f0f0fu)<<4)|((v&0xf0f0f0f0u)>>4); + if(step&8)v=((v&0x00ff00ffu)<<8)|((v&0xff00ff00u)>>8); + if(step&16)v=(v<<16)|(v>>16); + return v; +} + +int finite_roles(const vector& word,int possible) { + uint32_t matrix[4][4]{};int occurrence[16]{}; + for(int i=0;i<4;++i)matrix[i][i]=1; + for(int letter:word) { + auto &gate=gates[letter]; + int step=gate.steps[occurrence[letter]++]; + for(int row=0;row<4;++row) { + uint32_t inner=0; + for(int col=0;col<4;++col)if((gate.x>>col)&1)inner^=matrix[row][col]; + uint32_t delta=inner^translate(inner,step); + for(int col=0;col<4;++col)if((gate.y>>col)&1)matrix[row][col]^=delta; + } + } + int roles=0; + for(int i=0;i<4;++i) { + for(int j=0;j<4;++j)if(i!=j && matrix[i][j])return 0; + if(__builtin_popcount(matrix[i][i])!=1)return 0; + if(((possible>>i)&1) && matrix[i][i]==1)roles|=1<>families; + uint64_t raw=0, traces=0, reversed=0, survivors=0; + for(int family=0;family>n>>possible;gates.resize(n); + vector word; + for(int j=0;j>gates[j].x>>gates[j].y>>count;gates[j].m=0; + for(int i=0;i<4;++i)if((gates[j].x>>i)&1)gates[j].m|=gates[j].y<<(4*i); + for(int k=0;k backwards(word.rbegin(),word.rend()); + if(word>least_trace(backwards))continue;++reversed; + int roles=finite_roles(word,possible);if(!roles)continue; + unsigned char record[18];binary.read(reinterpret_cast(record),18); + if(!binary)throw runtime_error("Binary records ended early"); + for(int j=0;j<8;++j) + if(record[2*j]+256*record[2*j+1]!=gates[word[j]].m) + throw runtime_error("The independently retained word differs"); + if(record[16]+256*record[17]!=roles)throw runtime_error("The ancilla mask differs"); + ++survivors; + } while(next_permutation(word.begin(),word.end())); + } + if(binary.peek()!=char_traits::eof())throw runtime_error("Unused binary records"); + int extra;if(input>>extra)throw runtime_error("Unused family input"); + cout<<"{\"status\":\"PASS_INDEPENDENT_RANK3_ORDER_AND_QUOTIENT_REPLAY\",\"families\":"<>i)&1)*((y>>j)&1) << (4*i+j) for i in range(4) for j in range(4)) + +projectors = [(x,y,outer(x,y)) for x in range(1,16) for y in range(1,16) if (x&y).bit_count()%2] +patterns = sorted(set(m&OFF for x,y,m in projectors)-{0}) + +def strong(space): + edges = 0 + for m in space: + edges |= m + for i in range(4): + seen = 1 << i + while True: + nxt = seen + for j in range(4): + if seen >> j & 1: + nxt |= (edges >> (4*j)) & 15 + if nxt == seen:break + seen = nxt + if seen != 15:return False + return True + +def canonical(space): + return min(tuple(sorted(sum(((m>>(4*i+j))&1) << (4*p[i]+p[j]) for i in range(4) for j in range(4)) for m in space)) for p in permutations(range(4))) + +start = time() +spaces = {(0,)} +levels = [] +for dimension in range(1,4): + nxt = set() + for space in spaces: + for v in patterns: + if v not in space: + nxt.add(tuple(sorted(space + tuple(x^v for x in space)))) + spaces = nxt + irreducible = [s for s in spaces if strong(s)] + representatives = sorted(set(canonical(s) for s in irreducible)) + record = dict(dimension=dimension, spaces=len(spaces), irreducible_spaces=len(irreducible), representatives=[dict(space=s, projectors=[(x,y) for x,y,m in projectors if m&OFF in s]) for s in representatives]) + levels.append(record) + print(json.dumps(dict(dimension=dimension, spaces=len(spaces), irreducible=len(irreducible), classes=len(representatives), seconds=time()-start)),flush=True) +(ROOT/'off-pattern-spaces.json').write_text(json.dumps(dict(projectors=len(projectors), off_patterns=len(patterns), levels=levels),indent=2)+'\n') diff --git a/research/bit-three-active-one-returned/independent-sources/work/four-register/independent/rank2_binary.py b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent/rank2_binary.py new file mode 100644 index 0000000000..0652768a24 --- /dev/null +++ b/research/bit-three-active-one-returned/independent-sources/work/four-register/independent/rank2_binary.py @@ -0,0 +1,49 @@ +"""Write all retained rank-two orders before the finite quotient filter.""" +import hashlib,json,struct +from pathlib import Path + +root=Path(__file__).parent +families=json.loads((root.parent/'dirty_rank2.json').read_text())['families'] + +def outer(x,y): + return sum(y<<(4*i) for i in range(4) if x>>i&1) + +def commute(a,b): + x,y=a;u,v=b + return (outer(x,v) if (y&u).bit_count()%2 else 0)==(outer(u,y) if (v&x).bit_count()%2 else 0) + +def normalized(w,c): + result=[];left=list(range(len(w))) + while left: + choices=[i for i in left if all(c[w[j]][w[i]] for j in left if jj:blocked=True;break + if blocked:continue + counts[j]-=1 + yield from orders(counts,c,w+(j,)) + counts[j]+=1 + +counts=[] +p=root/'rank2-words.bin' +with p.open('wb') as f: + for family in families: + ns=family['projectors'];c=[[commute(a,b) for b in ns] for a in ns] + anc=sum(1<>i&1) + +parser=argparse.ArgumentParser(description=__doc__) +parser.add_argument('stage',choices=['pools','orders','binary']) +stage=parser.parse_args().stage +pools=catalogue() +if stage=='pools': + path=ROOT/'rank3-pools.txt' + with path.open('w') as f: + f.write(f'{len(pools)}\n') + for pool in pools: + s=pool['space'];assert all(s[i]^s[j]==s[i^j] for i in range(8) for j in range(8)) + ns=pool['projectors'];f.write(f'{len(ns)}\n') + for x,y in ns:f.write(f'{x} {y} {s.index(outer(x,y)&0x7bde)}\n') +elif stage=='orders': + fs=families();path=ROOT/'rank3-word-input.txt' + with path.open('w') as f: + f.write(f'{len(fs)}\n') + for rec in fs: + ns=pools[rec['class']]['projectors'];f.write(f"{len(ns)} {rec['possible_ancilla']}\n") + for (x,y),c in zip(ns,rec['counts']):f.write(f'{x} {y} {c}\n') +else: + fs=families();path=ROOT/'rank3-words.bin';count=0 + with path.open('wb') as f,(ROOT/'rank3-parity-survivors.jsonl').open() as inp: + for line in inp: + rec=json.loads(line);pool=pools[fs[rec['family']]['class']]['projectors'] + f.write(struct.pack('<9H',*(outer(*pool[j]) for j in rec['order']),rec['ancilla_mask']));count+=1 + print(json.dumps({'records':count,'bytes':path.stat().st_size})) +print(json.dumps({'file':path.name,'sha256':hashlib.sha256(path.read_bytes()).hexdigest()})) diff --git a/research/bit-three-active-one-returned/multisets.cpp b/research/bit-three-active-one-returned/multisets.cpp new file mode 100644 index 0000000000..b5fafc6fb3 --- /dev/null +++ b/research/bit-three-active-one-returned/multisets.cpp @@ -0,0 +1,98 @@ +#include +#include +#include +#include +using namespace std; + +struct Projector { int x, y, off; }; +vector p; +vector counts; +vector irreducible_cache; +long long visited=0, distance_ok=0, rank_ok=0, accepted=0; +int class_index; + +int binary_rank(vector a) { + int pivots[16]={}, rank=0; + for(int x:a) while(x) { + int k=31-__builtin_clz((unsigned)x); + if(pivots[k]) x^=pivots[k]; + else { pivots[k]=x; ++rank; break; } + } + return rank; +} + +bool irreducible(int support) { + int &cached=irreducible_cache[support]; + if(cached>=0) return cached; + for(int start=1;start<16;++start) { + unsigned span=1u|(1u<>j)&1) { + if((span>>p[j].x)&1) continue; + bool active=false; + for(int v=0;v<16;++v) if(((span>>v)&1) && __builtin_parity((unsigned)(v&p[j].y))) active=true; + if(active) { + unsigned old=span; + for(int v=0;v<16;++v) if((old>>v)&1) span|=1u<<(v^p[j].x); + changed=true; + } + } + } + if(span!=65535) return cached=0; + } + return cached=1; +} + +void check() { + ++visited; + int bad=0, support=0; + vector off; + for(int j=0;j<(int)p.size();++j) if(counts[j]) { support|=1< augmented; + for(int j=0;j<(int)p.size();++j) if(counts[j]) augmented.push_back(p[j].off | (((p[j].x>>a)&(p[j].y>>a)&1)<<3)); + if(binary_rank(augmented)<=3) possible|=1<>number; + for(class_index=0;class_index>n; + p.resize(n);counts.assign(n,0);irreducible_cache.assign(1<>q.x>>q.y>>q.off; + enumerate(0,8); + } + cerr<<"{\"classes\":"< +#include +#include +#include +#include +using namespace std; + +struct Projector { int x,y,m; }; +vector p; +vector counts, word; +bool commutes[16][16]; +int family_index, possible_ancilla; +long long prefixes=0, normal_orders=0, reversed_orders=0, parity_survivors=0; +const int ID=0x8421, OFF=0x7bde; + +int outer(int x,int y) { + int result=0; + for(int i=0;i<4;++i) if((x>>i)&1) result|=y<<(4*i); + return result; +} + +vector normalize(vector w) { + vector result; + unsigned remaining=255; + while(remaining) { + int choice=-1; + for(int i=0;i<8;++i) if((remaining>>i)&1) { + bool available=true; + for(int j=0;j>j)&1) && !commutes[w[i]][w[j]]) available=false; + if(available && (choice<0 || w[i]>bit)&1) { + int row=0; + for(int j=0;j<8;++j) row|=((p[word[j]].m>>bit)&1)<=0;--k) if(pivots[k] && ((row>>k)&1)) row^=pivots[k]; + for(int k=0;k<8;++k) if(!pivots[k]) compact|=((row>>k)&1)< polynomial{}; + polynomial[0]=ID; + for(int j=0;j<8;++j) { + array next{}; + auto &gate=p[word[j]]; + for(int g=0;g<32;++g) if(polynomial[g]) { + int m=polynomial[g], mx=0; + for(int i=0;i<4;++i) mx|=__builtin_parity((unsigned)(((m>>(4*i))&15)&gate.x))<>(5*i))&1) { ++diagonal_count[i];exponent[i]=g; } + } + int valid=0; + for(int i=0;i<4;++i) if(diagonal_count[i]!=1) return 0; + for(int a=0;a<4;++a) if(((possible_ancilla>>a)&1) && exponent[a]==0) valid|=1<normalize(reversed)) return; + ++reversed_orders; + int valid=parity_check(); + if(!valid) return; + ++parity_survivors; + cout<<"{\"family\":"<=0 && commutes[j][word[k]];--k) if(word[k]>j) { normal=false;break; } + if(!normal) continue; + --counts[j];word.push_back(j);enumerate();word.pop_back();++counts[j]; + } +} + +int main(int argc,char**argv) { + if(argc!=2) return 2; + ifstream input(argv[1]);int families;input>>families; + for(family_index=0;family_index>n>>possible_ancilla; + p.resize(n);counts.resize(n); + for(int j=0;j>p[j].x>>p[j].y>>counts[j];p[j].m=outer(p[j].x,p[j].y); } + for(int i=0;i +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using V = std::array; + +// Use a primitive integer row with a positive leading entry. +void normalize(V& v) { + int64_t divisor = 0; + for (int64_t x : v) divisor = std::gcd(divisor, std::abs(x)); + if (!divisor) return; + int leading = 0; + while (!v[leading]) ++leading; + if (v[leading] < 0) divisor = -divisor; + for (int64_t& x : v) x /= divisor; +} + +int pivot(const V& v) { + for (int i = 0; i < 8; ++i) { + if (v[i]) return i; + } + return 8; +} + +struct Rows { + std::array rows{}; + int size = 0; + bool operator==(const Rows& other) const { return rows == other.rows; } +}; + +struct HashRows { + size_t operator()(const Rows& basis) const { + size_t hash = 0; + for (const auto& row : basis.rows) { + for (int64_t x : row) hash = (hash ^ size_t(x + 97)) * 1099511628211ull; + } + return hash; + } +}; + +V reduce(V v, const Rows& basis) { + for (int a = 0; a < basis.size; ++a) { + const V& row = basis.rows[a]; + int p = pivot(row); + int64_t coefficient = v[p]; + if (coefficient) { + for (int i = 0; i < 8; ++i) { + v[i] = row[p] * v[i] - coefficient * row[i]; + } + normalize(v); + } + } + return v; +} + +Rows append(Rows basis, V v) { + v = reduce(v, basis); + if (pivot(v) == 8) return basis; + normalize(v); + int p = pivot(v); + for (int a = 0; a < basis.size; ++a) { + int64_t coefficient = basis.rows[a][p]; + if (coefficient) { + for (int i = 0; i < 8; ++i) { + basis.rows[a][i] = v[p] * basis.rows[a][i] - coefficient * v[i]; + } + normalize(basis.rows[a]); + } + } + basis.rows[basis.size++] = v; + std::sort(basis.rows.begin(), basis.rows.begin() + basis.size, + [](const V& a, const V& b) { return pivot(a) < pivot(b); }); + return basis; +} + +V vec(int mask) { + V v{}; + for (int i = 0; i < 8; ++i) v[i] = (mask >> i) & 1; + return v; +} + +int binaryrank(std::vector rows) { + int basis[8]{}, rank = 0; + for (int v : rows) { + for (int i = 7; i >= 0; --i) { + if (!(v >> i & 1)) continue; + if (basis[i]) { + v ^= basis[i]; + } else { + basis[i] = v; + ++rank; + break; + } + } + } + return rank; +} + +// Binary 4 by 4 matrices use row-major bit order. +constexpr int ID = 0x8421; +constexpr int OFF = 0xffff ^ ID; +constexpr int OFFBITS[12] = {1,2,3,4,6,7,8,9,11,12,13,14}; + +int outer(int x, int y) { + int m = 0; + for (int i = 0; i < 4; ++i) if (x >> i & 1) m |= y << (4*i); + return m; +} + +std::pair decode(int m) { + int x = 0, y = 0; + for (int i = 0; i < 4; ++i) { + int row = (m >> (4*i)) & 15; + if (row) { + if (y && y != row) throw std::runtime_error("Projector rank is not one"); + y = row; + x |= 1 << i; + } + } + if (!x || !y || !(__builtin_parity(x & y))) { + throw std::runtime_error("Invalid rank-one projector"); + } + return {x,y}; +} + +int times_projection(int m, int x, int y) { + int mx = 0; + for (int i = 0; i < 4; ++i) mx |= __builtin_parity(((m >> (4*i)) & 15) & x) << i; + return outer(mx,y); +} + +struct KeyHash { + size_t operator()(const V& v) const { + size_t hash = 0; + for (int64_t x : v) hash = (hash ^ size_t(x + 4097)) * 1099511628211ull; + return hash; + } +}; + +struct Group { + V key; + int mask, matrix; +}; + +struct Solver { + std::array ns; + int ancilla_mask = 0; + std::vector> terms; + std::vector offrows; + std::unordered_set seen; + uint64_t states[4]{}, parityprune = 0, zeroprune = 0, terminal = 0, robust = 0; + std::ofstream* cert = nullptr; + int wordidx = 0; + + void init() { + terms = {{0, ID}}; + for (int j = 0; j < 8; ++j) { + auto [x,y] = decode(ns[j]); + std::vector> next; + for (auto [mask, matrix] : terms) { + int variable = times_projection(matrix, x, y); + int constant = matrix ^ variable; + if (constant) next.emplace_back(mask, constant); + if (variable) next.emplace_back(mask | (1 << j), variable); + } + terms = next; + } + for (int bit : OFFBITS) { + int row = 0; + for (int i = 0; i < 8; ++i) row |= ((ns[i] >> bit) & 1) << i; + offrows.push_back(row); + } + } + + // Check whether a target is a linear combination of at most two physical frames. + bool target_rank_small(int mask, const Rows& relations) { + for (int i = 0; i < 8; ++i) { + for (int j = i + 1; j < 8; ++j) { + std::vector basis(relations.rows.begin(), + relations.rows.begin() + relations.size); + auto add = [&](V v) { + for (const auto& row : basis) { + int p = pivot(row); + int64_t coefficient = v[p]; + if (coefficient) { + for (int k = 0; k < 8; ++k) { + v[k] = row[p] * v[k] - coefficient * row[k]; + } + normalize(v); + } + } + if (pivot(v) < 8) { + normalize(v); + basis.push_back(v); + std::sort(basis.begin(), basis.end(), + [](const V& a, const V& b) { return pivot(a) < pivot(b); }); + } + }; + add(vec(1 << i)); + add(vec(1 << j)); + int before = basis.size(); + add(vec(mask)); + if (int(basis.size()) == before) return true; + } + } + return false; + } + + void go(const Rows& relations) { + if (!seen.insert(relations).second) return; + ++states[relations.size]; + + auto parity = offrows; + for (int a = 0; a < relations.size; ++a) { + int row = 0; + for (int j = 0; j < 8; ++j) { + row |= (std::abs(relations.rows[a][j]) & 1) << j; + } + parity.push_back(row); + } + if (binaryrank(parity) > 3) { + ++parityprune; + return; + } + for (int i = 0; i < 8; ++i) { + if (pivot(reduce(vec(1 << i), relations)) == 8) { + ++zeroprune; + return; + } + } + + // Form exact quotient keys with one common integer denominator. + int64_t denominator = 1; + for (int a = 0; a < relations.size; ++a) { + denominator = std::lcm(denominator, relations.rows[a][pivot(relations.rows[a])]); + } + std::unordered_map, KeyHash> groups; + for (auto [mask, matrix] : terms) { + V key = vec(mask); + for (int64_t& x : key) x *= denominator; + for (int a = 0; a < relations.size; ++a) { + int p = pivot(relations.rows[a]); + if (mask >> p & 1) { + for (int j = 0; j < 8; ++j) { + key[j] -= (denominator / relations.rows[a][p]) * relations.rows[a][j]; + } + } + } + auto [it, inserted] = groups.emplace(key, std::make_pair(mask, 0)); + it->second.second ^= matrix; + } + std::vector active; + bool has_offdiagonal = false; + for (const auto& [key, term] : groups) { + if (term.second) { + active.push_back({key, term.first, term.second}); + has_offdiagonal |= (term.second & OFF) != 0; + } + } + + if (!has_offdiagonal) { + int targets[4] = {-1, -1, -1, -1}; + for (const auto& group : active) { + for (int w = 0; w < 4; ++w) { + if (group.matrix >> (5 * w) & 1) { + if (targets[w] != -1) throw std::logic_error("A diagonal unit has multiple terms"); + targets[w] = group.mask; + } + } + } + for (int target : targets) { + if (target < 0) throw std::logic_error("A diagonal unit is zero"); + } + ++terminal; + for (int ancilla = 0; ancilla < 4; ++ancilla) { + if (!(ancilla_mask >> ancilla & 1)) continue; + Rows constrained = relations; + if (pivot(reduce(vec(targets[ancilla]), constrained)) != 8) { + if (constrained.size == 3) continue; + constrained = append(constrained, vec(targets[ancilla])); + } + bool zero = false; + for (int i = 0; i < 8; ++i) zero |= pivot(reduce(vec(1 << i), constrained)) == 8; + if (zero) continue; + bool survives = true; + for (int w = 0; w < 4; ++w) { + if (w != ancilla) survives &= !target_rank_small(targets[w], constrained); + } + if (!survives) continue; + ++robust; + if (cert) { + *cert << wordidx << ' ' << ancilla; + for (int projector : ns) *cert << ' ' << projector; + *cert << " : "; + for (int a = 0; a < constrained.size; ++a) { + for (int64_t x : constrained.rows[a]) *cert << x << ','; + *cert << " ; "; + } + *cert << " : "; + for (int target : targets) *cert << target << ' '; + *cert << '\n'; + } + } + return; + } + if (relations.size == 3) return; + + // A nonzero off-diagonal entry must cancel with a partner group. + int best = -1, best_bit = -1, best_count = 1000; + for (int a = 0; a < int(active.size()); ++a) { + for (int bit : OFFBITS) { + if (!(active[a].matrix >> bit & 1)) continue; + int count = 0; + for (int b = 0; b < int(active.size()); ++b) { + if (a != b && (active[b].matrix >> bit & 1)) ++count; + } + if (count < best_count) { + best = a; + best_bit = bit; + best_count = count; + } + } + } + for (int b = 0; b < int(active.size()); ++b) { + if (b != best && (active[b].matrix >> best_bit & 1)) { + V difference{}; + for (int i = 0; i < 8; ++i) { + difference[i] = ((active[best].mask >> i) & 1) - ((active[b].mask >> i) & 1); + } + Rows next = append(relations, difference); + if (next.size == relations.size) { + throw std::logic_error("Partner already in this group"); + } + go(next); + } + } + } +}; + +int main(int argc, char** argv) { + try { + if (argc < 4 || argc > 6) { + throw std::runtime_error("Usage: integer_engine INPUT OUTPUT_PREFIX [START [COUNT]]"); + } + uint64_t start = argc >= 5 ? std::stoull(argv[4]) : 0; + uint64_t limit = argc >= 6 ? std::stoull(argv[5]) : std::numeric_limits::max(); + // The third argument identifies the result schema. It must be 'dirty'. + if (std::string(argv[3]) != "dirty") throw std::runtime_error("Expected dirty mode"); + std::ifstream input(argv[1], std::ios::binary); + if (!input) throw std::runtime_error("Cannot open input"); + input.seekg(0,std::ios::end); + auto bytes = input.tellg(); + if (bytes < 0 || bytes % 18 != 0) throw std::runtime_error("Invalid input length"); + uint64_t available = uint64_t(bytes) / 18; + if (start > available) throw std::runtime_error("Start exceeds input count"); + uint64_t stop = start + std::min(limit, available-start); + input.seekg(start*18); + std::string prefix = argv[2]; + std::ofstream results(prefix+".chunks.jsonl"), candidates(prefix+".candidates.txt"), terminals(prefix+".terminals.jsonl"); + if (!results || !candidates || !terminals) throw std::runtime_error("Cannot open result paths"); + uint64_t states[4]{}, total_terminal = 0, total_robust = 0, parity = 0, zero = 0; + auto begin = std::chrono::steady_clock::now(); + for (uint64_t index = start; index < stop; ++index) { + unsigned char data[18]; + if (!input.read(reinterpret_cast(data),18)) throw std::runtime_error("Incomplete record"); + Solver solver; + for (int i=0;i<8;++i) solver.ns[i] = data[2*i] | (int(data[2*i+1])<<8); + solver.ancilla_mask = data[16] | (int(data[17])<<8); + if (solver.ancilla_mask < 1 || solver.ancilla_mask > 15) throw std::runtime_error("Invalid helper mask"); + solver.wordidx = index; + solver.cert = &candidates; + solver.init(); + solver.go(Rows{}); + for (int i=0;i<4;++i) states[i] += solver.states[i]; + total_terminal += solver.terminal; + total_robust += solver.robust; + parity += solver.parityprune; + zero += solver.zeroprune; + if (solver.terminal || solver.robust) { + terminals << "{\"word\":" << index << ",\"terminals\":" << solver.terminal << ",\"robust\":" << solver.robust << "}\n"; + } + if ((index+1-start)%1000 == 0 || index+1 == stop) { + results << "{\"start\":" << start << ",\"end\":" << index+1 << ",\"states\":[" << states[0] << ',' << states[1] << ',' << states[2] << ',' << states[3] << "],\"terminals\":" << total_terminal << ",\"robust\":" << total_robust << ",\"parity_prunes\":" << parity << ",\"zero_prunes\":" << zero << "}\n"; + results.flush(); + if (!results || !candidates || !terminals) throw std::runtime_error("Cannot write result"); + } + if ((index+1-start)%10000 == 0) { + double seconds = std::chrono::duration(std::chrono::steady_clock::now()-begin).count(); + std::cerr << index+1 << " / " << stop << "; terminals " << total_terminal << "; robust " << total_robust << "; seconds " << seconds << '\n'; + } + } + std::cout << "{\"start\":" << start << ",\"end\":" << stop << ",\"words\":" << stop-start << ",\"terminals\":" << total_terminal << ",\"robust\":" << total_robust << "}\n"; + } catch (const std::exception& error) { + std::cerr << error.what() << '\n'; + return 1; + } +} diff --git a/research/bit-three-active-one-returned/receipt.json b/research/bit-three-active-one-returned/receipt.json new file mode 100644 index 0000000000..f45209eb11 --- /dev/null +++ b/research/bit-three-active-one-returned/receipt.json @@ -0,0 +1,130 @@ +{ + "rank2": { + "multisets": 61347, + "families": 103, + "words": 27156 + }, + "rank3": { + "multisets": { + "classes": 2846, + "multisets": 11210628, + "distance_ok": 8623, + "rank_ok": 4020, + "irreducible": 4020 + }, + "orders": { + "families": 4020, + "prefixes": 28785353, + "commutation_orders": 7121514, + "reversal_orders": 3560923, + "parity_survivors": 1901600 + } + }, + "inputs": { + "2": { + "records": 27156, + "sha256": "f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee" + }, + "3": { + "records": 1901600, + "sha256": "97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911" + } + }, + "engines": { + "2": { + "rational": { + "start": 0, + "end": 27156, + "states": [ + 27156, + 30618, + 8831, + 893 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 4087, + "zero_prunes": 30420 + }, + "field101": { + "words": 27156, + "states": [ + 27156, + 30618, + 6004, + 364 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 3786, + "zero_frame_prunes": 28791, + "nonmonomial_diagonal": 0, + "input_fnv64": 14983660685661952600 + }, + "terminal_word_agreement": true, + "chunk_agreement": true + }, + "3": { + "rational": { + "start": 0, + "end": 1901600, + "states": [ + 1901600, + 2034962, + 440516, + 54780 + ], + "terminals": 538, + "robust": 0, + "parity_prunes": 151674, + "zero_prunes": 1913504 + }, + "field101": { + "words": 1901600, + "states": [ + 1901600, + 2034962, + 456961, + 48892 + ], + "terminals": 538, + "robust": 0, + "parity_prunes": 154079, + "zero_frame_prunes": 1914429, + "nonmonomial_diagonal": 0, + "input_fnv64": 6871862008808761687 + }, + "terminal_word_agreement": true, + "chunk_agreement": true + } + }, + "catalogue": [ + { + "dimension": 1, + "spaces": 104, + "irreducible_spaces": 0, + "classes": 0 + }, + { + "dimension": 2, + "spaces": 4964, + "irreducible_spaces": 634, + "classes": 45 + }, + { + "dimension": 3, + "spaces": 140281, + "irreducible_spaces": 63567, + "classes": 2846 + } + ], + "source_sha256": { + "field101.cpp": "5995e8d4cfd7a212a083c4764d271cae15bf0baeb09b6b2897e2601065c02ed9", + "generate.py": "bf6e5ae35550ef01638e27c29dcfedaabcc4868d75d2d3f54383b4da4d9a5920", + "multisets.cpp": "dc508c03f0526aed029989e2d74c135f20be75b083124cc577ca218193d5666b", + "orders.cpp": "b2c0ebe347fcc7e3744b43e59c48b97ce1f70bdb786e900b8025dc9ab59af78a", + "rational.cpp": "590b838fd6662fb98464e1549bf23b862b2fae784984ccf419932bfe0b059c84" + }, + "seconds": 52.19839906692505, + "status": "PASS_COMPLETE_FINITE_CHECKS" +} diff --git a/research/bit-three-active-one-returned/replay.log b/research/bit-three-active-one-returned/replay.log new file mode 100644 index 0000000000..2c5a53c36f --- /dev/null +++ b/research/bit-three-active-one-returned/replay.log @@ -0,0 +1,6 @@ +Catalogue: 1 104 0 0 +Catalogue: 2 4964 634 45 +Catalogue: 3 140281 63567 2846 +Exact checks: 2 27156 0 0 +Exact checks: 3 1901600 538 0 +Receipt: /Users/aliromman/Projects/IntegerMultiplicationBounds/work/project-final-cleanup-20261022/early-projects-audit/checks/returned-full/receipt.json diff --git a/research/bit-three-active-one-returned/replayed-fraction-terminals.json b/research/bit-three-active-one-returned/replayed-fraction-terminals.json new file mode 100644 index 0000000000..8ffd0c700b --- /dev/null +++ b/research/bit-three-active-one-returned/replayed-fraction-terminals.json @@ -0,0 +1,4313 @@ +{ + "status": "PASS_FRACTION_TERMINAL_REPLAY", + "words": 538, + "nodes": 2152, + "terminals": 538, + "candidates": 0, + "records": [ + { + "word": 1041970, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041971, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041972, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041973, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041974, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041975, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041976, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041977, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041978, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041979, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041980, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041981, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041982, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041983, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041984, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041985, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041986, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041987, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041988, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041989, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041990, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041991, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041992, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041993, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041994, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041995, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041996, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041997, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041998, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041999, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042000, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042001, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042002, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042003, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042004, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042005, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042006, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042007, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042008, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042009, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042010, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042011, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051053, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051054, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051055, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051056, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051057, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051058, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051059, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051060, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051061, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051062, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051063, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051064, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051065, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051066, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051067, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051068, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051069, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051070, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051071, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051072, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051073, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051074, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051075, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051076, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051077, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051078, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051079, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051080, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051081, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051082, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051083, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051084, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051085, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051086, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051087, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051088, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051089, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051090, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051091, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051092, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051093, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051094, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051095, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051096, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051097, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051098, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051099, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051100, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051101, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051102, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051103, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057454, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057455, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057456, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057457, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057458, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057459, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057460, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057461, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057462, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057463, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057464, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057465, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057466, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057467, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057468, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057469, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057470, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057471, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057472, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057473, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057474, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057475, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057476, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057477, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057478, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057479, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057480, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057481, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057482, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057483, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057484, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057485, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057486, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057487, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057488, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057489, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057490, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057491, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057492, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057493, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057494, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057495, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062157, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062158, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062159, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062160, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062161, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062162, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062163, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062164, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062165, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062166, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062167, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062168, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062169, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062196, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062197, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062198, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062199, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062200, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062201, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062202, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062203, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062204, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062205, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062206, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062207, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068548, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068549, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068550, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068551, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068552, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068553, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068554, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068555, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068556, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068557, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068558, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068559, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068560, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068561, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068562, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068563, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068564, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068565, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068566, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068567, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068568, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068569, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068570, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068571, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068572, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068573, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074361, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074362, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074363, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074364, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074365, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074366, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074367, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074368, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074369, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074370, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074371, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074372, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074373, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074374, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074375, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074376, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074377, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074378, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074379, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074380, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074381, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074382, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074383, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074384, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074385, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074386, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074387, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074388, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074389, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074390, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074391, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074392, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074393, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074394, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074395, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074396, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074397, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074398, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074399, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074400, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074401, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074402, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074403, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074404, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074405, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074406, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074407, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074408, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074409, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074410, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074411, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081061, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081062, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081063, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081064, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081065, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081066, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081067, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081068, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081069, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081070, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081071, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081072, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081073, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081074, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081075, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081076, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081077, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081078, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081079, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081080, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081081, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081082, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081083, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081084, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081085, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081086, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081087, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081088, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081089, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081090, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081091, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081092, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081093, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081094, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081095, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087162, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087163, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087164, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087165, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087166, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087167, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087168, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087169, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087196, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087197, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087198, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087199, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087200, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087201, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087202, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087203, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087204, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087205, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087206, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087207, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087208, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087209, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087210, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087211, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087212, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094815, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094816, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094817, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094818, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094819, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094820, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094821, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094822, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094823, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094824, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094825, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094826, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094827, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094828, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094829, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094830, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094831, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094832, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094833, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094834, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094835, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094836, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094837, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094838, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094839, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094840, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100463, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100464, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100465, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100466, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100467, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100468, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100469, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100470, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100471, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100472, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100473, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100474, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100475, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100476, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100477, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100478, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100479, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100480, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100481, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100482, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100483, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100484, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100485, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100486, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100487, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100488, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100489, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100490, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100491, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100492, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100493, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100494, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100495, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100496, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100497, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100498, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100499, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100500, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100501, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100502, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100503, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100504, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100505, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100506, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100507, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100508, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100509, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100510, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100511, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100512, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100513, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106857, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106858, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106859, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106860, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106861, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106862, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106863, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106864, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106865, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106866, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106867, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106868, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106869, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106870, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106871, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106872, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106873, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106874, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106875, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106876, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106877, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106878, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106879, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106880, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106881, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106882, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106883, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106884, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106885, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106886, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106887, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106888, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106889, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106890, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106891, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112958, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112959, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112960, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112961, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112962, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112963, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112964, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112965, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112966, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112967, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112968, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112969, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112970, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112971, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112972, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112973, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112974, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112975, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112976, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112977, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112978, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112979, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112980, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112981, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112982, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112983, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112984, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112985, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112986, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112987, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112988, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112989, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112990, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112991, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112992, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112993, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112994, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112995, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112996, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112997, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112998, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112999, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113000, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113001, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113002, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113003, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113004, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113005, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113006, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113007, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113008, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + } + ] +} diff --git a/research/bit-three-active-one-returned/replayed-independent-receipt.json b/research/bit-three-active-one-returned/replayed-independent-receipt.json new file mode 100644 index 0000000000..192efa7cee --- /dev/null +++ b/research/bit-three-active-one-returned/replayed-independent-receipt.json @@ -0,0 +1,83 @@ +{ + "status": "PASS_INDEPENDENT_RETURNED_REGISTER_FRONT_END", + "stages": [ + "catalogue", + "independent-catalogue", + "rank2-families", + "check_rank3_multisets-compile", + "check_rank3_orders-compile", + "rank2-multisets", + "rank3-multisets", + "input-binding", + "rank2-orders", + "rank3-orders", + "polynomial-controls" + ], + "reports": { + "OFF-CATALOGUE-RESULT.json": { + "status": "PASS_INDEPENDENT_OFF_PATTERN_CATALOGUE", + "projectors": 120, + "nonzero_off_patterns": 104, + "levels": [ + { + "dimension": 1, + "spaces": 104, + "strongly_connected_spaces": 0, + "classes": 0, + "representatives_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "eight_multisets": 0 + }, + { + "dimension": 2, + "spaces": 4964, + "strongly_connected_spaces": 634, + "classes": 45, + "representatives_sha256": "55a3766dbfeb7e83ffbeba2ac6f172d1a7c3eeb9653a2ee634f95ba82f85950b", + "eight_multisets": 61347 + }, + { + "dimension": 3, + "spaces": 140281, + "strongly_connected_spaces": 63567, + "classes": 2846, + "representatives_sha256": "83f52db23039b19bcaee7e94b05fd2b2c2033a3a41998c665aa5e6bdd537afc8", + "eight_multisets": 11210628 + } + ] + }, + "INPUT-BINDING-RESULT.json": { + "status": "PASS_CATALOGUE_MULTISET_WORD_BINARY_BINDING", + "pool_classes": 2846, + "multiset_rows": 4020, + "independent_multiset_rows": 4020, + "binary_records": 1901600, + "binary_bytes": 34228800, + "binary_sha256": "97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911" + }, + "RANK2-FRONT-END-RESULT.json": { + "status": "PASS_INDEPENDENT_RANK2_FRONT_END", + "families": 103, + "raw_orders": 831600, + "commutation_orders": 54294, + "reversal_orders": 27156, + "binary_word_and_role_stream_identical": true, + "binary_bytes": 488808, + "binary_sha256": "f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee" + }, + "RANK3-ORDERS-RESULT.json": { + "status": "PASS_INDEPENDENT_RANK3_ORDER_AND_QUOTIENT_REPLAY", + "families": 4020, + "raw_orders": 41706000, + "commutation_orders": 7121514, + "reversal_orders": 3560923, + "quotient_survivors": 1901600, + "binary_word_and_role_stream_identical": true + } + }, + "polynomial_controls": { + "formal_polynomial_controls": 7, + "passed": true, + "scope": "Formal polynomial core; these fixtures are not paid-call circuits." + }, + "source_manifest_sha256": "e67a75e9f09168f886223d10b93e0cf580c7e3ff45391c1719e67fccff541a54" +} diff --git a/research/bit-three-active-one-returned/replayed-receipt.json b/research/bit-three-active-one-returned/replayed-receipt.json new file mode 100644 index 0000000000..6ac3841847 --- /dev/null +++ b/research/bit-three-active-one-returned/replayed-receipt.json @@ -0,0 +1,131 @@ +{ + "rank2": { + "multisets": 61347, + "families": 103, + "words": 27156 + }, + "rank3": { + "multisets": { + "classes": 2846, + "multisets": 11210628, + "distance_ok": 8623, + "rank_ok": 4020, + "irreducible": 4020 + }, + "orders": { + "families": 4020, + "prefixes": 28785353, + "commutation_orders": 7121514, + "reversal_orders": 3560923, + "parity_survivors": 1901600 + } + }, + "inputs": { + "2": { + "records": 27156, + "sha256": "f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee" + }, + "3": { + "records": 1901600, + "sha256": "97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911" + } + }, + "engines": { + "2": { + "rational": { + "start": 0, + "end": 27156, + "states": [ + 27156, + 30618, + 8831, + 893 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 4087, + "zero_prunes": 30420 + }, + "field101": { + "words": 27156, + "states": [ + 27156, + 30618, + 6004, + 364 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 3786, + "zero_frame_prunes": 28791, + "nonmonomial_diagonal": 0, + "input_fnv64": 14983660685661952600 + }, + "terminal_word_agreement": true, + "chunk_agreement": true + }, + "3": { + "rational": { + "start": 0, + "end": 1901600, + "states": [ + 1901600, + 2034962, + 440516, + 54780 + ], + "terminals": 538, + "robust": 0, + "parity_prunes": 151674, + "zero_prunes": 1913504 + }, + "field101": { + "words": 1901600, + "states": [ + 1901600, + 2034962, + 456961, + 48892 + ], + "terminals": 538, + "robust": 0, + "parity_prunes": 154079, + "zero_frame_prunes": 1914429, + "nonmonomial_diagonal": 0, + "input_fnv64": 6871862008808761687 + }, + "terminal_word_agreement": true, + "chunk_agreement": true + } + }, + "catalogue": [ + { + "dimension": 1, + "spaces": 104, + "irreducible_spaces": 0, + "classes": 0 + }, + { + "dimension": 2, + "spaces": 4964, + "irreducible_spaces": 634, + "classes": 45 + }, + { + "dimension": 3, + "spaces": 140281, + "irreducible_spaces": 63567, + "classes": 2846 + } + ], + "source_sha256": { + "field101.cpp": "5995e8d4cfd7a212a083c4764d271cae15bf0baeb09b6b2897e2601065c02ed9", + "generate.py": "bf6e5ae35550ef01638e27c29dcfedaabcc4868d75d2d3f54383b4da4d9a5920", + "multisets.cpp": "dc508c03f0526aed029989e2d74c135f20be75b083124cc577ca218193d5666b", + "orders.cpp": "b2c0ebe347fcc7e3744b43e59c48b97ce1f70bdb786e900b8025dc9ab59af78a", + "rational.cpp": "590b838fd6662fb98464e1549bf23b862b2fae784984ccf419932bfe0b059c84", + "verify.py": "b889f5a43be0b404932b7b876fda82404a2ed0f6a4e9be34e81ec6b184ae3e95" + }, + "seconds": 125.18288516998291, + "status": "PASS_COMPLETE_FINITE_CHECKS" +} diff --git a/research/bit-three-active-one-returned/review/CHECKED-FILES.json b/research/bit-three-active-one-returned/review/CHECKED-FILES.json new file mode 100644 index 0000000000..0956e5a595 --- /dev/null +++ b/research/bit-three-active-one-returned/review/CHECKED-FILES.json @@ -0,0 +1,192 @@ +{ + "package": "work/project-final-cleanup-20261022/early-projects-audit/packages/bit-three-active-one-returned", + "status": "PASS_INDEPENDENT_AGENT_REVIEW", + "files": [ + { + "path": "AUDIT.txt", + "bytes": 17472, + "sha256": "1d122a587e3d876005ef3362be16dc8f34aa871bed7ef6a53fcb7bc3f661a3f3" + }, + { + "path": "PROOF.txt", + "bytes": 9115, + "sha256": "0e36d58d380b73f3a7a32e157704681803a1f56232268acb9f97d14d23a4f78e" + }, + { + "path": "README.md", + "bytes": 6008, + "sha256": "5ce12db360c1280f7d08fe77fb7e8817279bdabe9eb27b63ff76ae433a10253f" + }, + { + "path": "REPLAY.txt", + "bytes": 2515, + "sha256": "7ec83899df66c47e3d24f988e9824ddd2fa2ae6065c6e88e62b9816fe89f71eb" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 6970, + "sha256": "1c5bfeb26d41f9a3fdf637b16fc354fff6f9a63a3ce994ef14aeb54c849993cd" + }, + { + "path": "field101.cpp", + "bytes": 14736, + "sha256": "5995e8d4cfd7a212a083c4764d271cae15bf0baeb09b6b2897e2601065c02ed9" + }, + { + "path": "generate.py", + "bytes": 10838, + "sha256": "bf6e5ae35550ef01638e27c29dcfedaabcc4868d75d2d3f54383b4da4d9a5920" + }, + { + "path": "independent-receipt.json", + "bytes": 4289, + "sha256": "3078c86bc7e5ce80f0ff77e6300ca78ae4c52cad3f605bb8936c63fb2d305305" + }, + { + "path": "independent-replay.log", + "bytes": 3742, + "sha256": "9dfca60a366608bad2de2224d01d6d31a129bf1bbc90603ad2b673fb1b0e24e8" + }, + { + "path": "independent-sources/work/four-register/DIRTY-MODEL.txt", + "bytes": 3638, + "sha256": "c42806af71be2e44dc4e59c75134795db7684ce0cc57ebfaecd3da9252b77c9a" + }, + { + "path": "independent-sources/work/four-register/F101-ARITHMETIC.txt", + "bytes": 3513, + "sha256": "540dfa9f49488b92ee24e9f82704ac2032aa2117957dd4c9cbcf33ca4fafe09f" + }, + { + "path": "independent-sources/work/four-register/dirty_ancilla.py", + "bytes": 6293, + "sha256": "81d8df0b7b08e0ad89dc13f65325e7091cb9c201d9c5bc4d8637f8325d0be876" + }, + { + "path": "independent-sources/work/four-register/dirty_f101_controls.py", + "bytes": 2729, + "sha256": "d42cdf78c7a58f011c34d54a7fb1881c4a81fbe6179571d096cbe58ca81c5331" + }, + { + "path": "independent-sources/work/four-register/dirty_h_alphabet.py", + "bytes": 4551, + "sha256": "0f889a71e9d14b26cc5fc226f4ef72ab276a2ce71b11cd3535c50be1bc4ad5dd" + }, + { + "path": "independent-sources/work/four-register/dirty_rank2.py", + "bytes": 2323, + "sha256": "51da1918d6219dfb2a59d4a6c27885d41113cc3c07a8f659d7df0254d5b7d3c7" + }, + { + "path": "independent-sources/work/four-register/independent/fraction-terminal-audit.json", + "bytes": 88380, + "sha256": "c9bf5d77f3e7127828f8d35657d9c3d2c4a4a12aa3143f62219021355c3d2a20" + }, + { + "path": "independent-sources/work/four-register/independent/off_pattern_spaces.py", + "bytes": 2023, + "sha256": "51ef2a52c9639bb2a236e68d912a1d5877600e4956083ec9015420bca5adbd50" + }, + { + "path": "independent-sources/work/four-register/independent/rank2_binary.py", + "bytes": 1747, + "sha256": "6231b6fde84fc680285dd2816a8d3f362ae35563435d5c1a4eb3bb512a47b10d" + }, + { + "path": "independent-sources/work/four-register/independent/rank3_data.py", + "bytes": 1867, + "sha256": "d7021e4d59bffd3cc17456841186b464bc91f18c878ec6eded7fac6ade393b19" + }, + { + "path": "independent-sources/work/four-register/independent-audit/DIRTY-AUDIT.txt", + "bytes": 17472, + "sha256": "1d122a587e3d876005ef3362be16dc8f34aa871bed7ef6a53fcb7bc3f661a3f3" + }, + { + "path": "independent-sources/work/four-register/independent-audit/PROOF-AUDIT.txt", + "bytes": 8163, + "sha256": "c9744f9895dd59bf7c9e05df2dbbebcc440b33ab86e829a054ae61ed5518ec12" + }, + { + "path": "independent-sources/work/four-register/independent-audit/check_input_binding.py", + "bytes": 3164, + "sha256": "6ff60a74b38d7e7cbc480fd751df2209c0f9181f20b8f20f51ed644b69c5b578" + }, + { + "path": "independent-sources/work/four-register/independent-audit/check_off_catalogue.py", + "bytes": 3810, + "sha256": "e4c07f111a59e15b66fd99035e75ac99df5bee6c3fb48792f08022003b92592e" + }, + { + "path": "independent-sources/work/four-register/independent-audit/check_rank2_orders.py", + "bytes": 3357, + "sha256": "58dff791aabf5834816465e2fc0e451eb38a20d99affd5d16fed2d37f328e976" + }, + { + "path": "independent-sources/work/four-register/independent-audit/check_rank3_multisets.cpp", + "bytes": 4331, + "sha256": "c7a34479a2229fe3151d50ffb9ba676e7510d7cb7c21f3dbc3a42401ec2c8084" + }, + { + "path": "independent-sources/work/four-register/independent-audit/check_rank3_orders.cpp", + "bytes": 6002, + "sha256": "7b6b915422ba6c2443ab72f6a8f16a994416cf6e4f9ed3425c76a94cac79db48" + }, + { + "path": "multisets.cpp", + "bytes": 3221, + "sha256": "dc508c03f0526aed029989e2d74c135f20be75b083124cc577ca218193d5666b" + }, + { + "path": "orders.cpp", + "bytes": 4211, + "sha256": "b2c0ebe347fcc7e3744b43e59c48b97ce1f70bdb786e900b8025dc9ab59af78a" + }, + { + "path": "rational.cpp", + "bytes": 15409, + "sha256": "590b838fd6662fb98464e1549bf23b862b2fae784984ccf419932bfe0b059c84" + }, + { + "path": "receipt.json", + "bytes": 3041, + "sha256": "ea38c17019d2f73a30b1062ec72b4736eb6dd95abbe8f09f358810323ad9fa94" + }, + { + "path": "replay.log", + "bytes": 287, + "sha256": "26de270bfb510ba3e60404617e4de005a1d83d6da287cae43db16742f8da2b1c" + }, + { + "path": "replayed-fraction-terminals.json", + "bytes": 88371, + "sha256": "3edc68fd8c7b31f7e76894138ae4622b70669282e7859026218cf3c6fdd3c03d" + }, + { + "path": "replayed-independent-receipt.json", + "bytes": 2737, + "sha256": "57bfb232c77b3b53240a38fe50ab652c362c65018747553e8f30f5a9507510d4" + }, + { + "path": "replayed-receipt.json", + "bytes": 3127, + "sha256": "d3a9983fee576c6d5539fab71134488315cf9548a7f0f4935479b311f1a968c8" + }, + { + "path": "verify.py", + "bytes": 683, + "sha256": "bf5db29902728da4920da3ca0e7658e0461dda5452af7c382a0f2bc94f3b5f33" + }, + { + "path": "verify_fraction_terminals.py", + "bytes": 2209, + "sha256": "249ead040dad96edfb9ac8ce562025b2b2402a9b0c18af2b4d9fce4a0e59aea2" + }, + { + "path": "verify_independent.py", + "bytes": 5338, + "sha256": "6bad22f0edf557002e315f145b1dd61e439fab02c098d63aa5fe71bb85764b9e" + } + ], + "scope": "Scoped nine-call obstruction, exactly four scalar roles, three invertible lower-triangular rational targets, one arbitrary restored role; no kappa improvement." +} diff --git a/research/bit-three-active-one-returned/review/CONTROLS.json b/research/bit-three-active-one-returned/review/CONTROLS.json new file mode 100644 index 0000000000..ff0268a997 --- /dev/null +++ b/research/bit-three-active-one-returned/review/CONTROLS.json @@ -0,0 +1,24 @@ +{ + "status": "PASS_BOUNDED_INDEPENDENT_CONTROLS", + "checks": [ + "Run this verifier without -O", + "optimized mode rejects before creating output", + "FileExistsError", + "occupied output is unchanged", + "Source hash: PROOF.txt", + "source mutation rejects before creating output", + "Invalid input length", + "Input size is not divisible by 18", + "nine calls realize three different lower triangular targets and all four input columns", + "omitted call 0 changes the endpoint", + "omitted call 1 changes the endpoint", + "omitted call 2 changes the endpoint", + "omitted call 3 changes the endpoint", + "omitted call 4 changes the endpoint", + "omitted call 5 changes the endpoint", + "omitted call 6 changes the endpoint", + "omitted call 7 changes the endpoint", + "omitted call 8 changes the endpoint", + "changed returned-role endpoint is rejected" + ] +} diff --git a/research/bit-three-active-one-returned/review/DEPENDENCY-AND-OVERLAP-PINS.json b/research/bit-three-active-one-returned/review/DEPENDENCY-AND-OVERLAP-PINS.json new file mode 100644 index 0000000000..d2daae042f --- /dev/null +++ b/research/bit-three-active-one-returned/review/DEPENDENCY-AND-OVERLAP-PINS.json @@ -0,0 +1,38 @@ +[ + { + "commit": "07a78bf335b0b5039a1fecd7cd74a0fe1d1605ea", + "path": "research/bit-three-register-lower-bound/README.md", + "sha256": "c12b33ef388deece0cbf891505a2ce2c0779a0c3a6cf1f0f7f7039bab59cbebd", + "bytes": 30934 + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/bit-mixed-target-register-compression/README.md", + "sha256": "0a937f6cbcc88718aa1b6b4be849883c331c54a392ce81dc3485ef10ddeedc39", + "bytes": 9723 + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/bit-parity-uniform-targets/README.md", + "sha256": "4096003398e8faed7489ed63d9fb2a4abbee974a8b2bacfcf0cf55a34cf87ff8", + "bytes": 16891 + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/bit-identical-three-targets-dirty/README.md", + "sha256": "56cb21f6587673aef5cd4e4794f57cc6e4fd73c80e75625c48cb0d387cb3a7c6", + "bytes": 8316 + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/bit-dirty-auxiliary-registers/README.md", + "sha256": "da984fddaa09bfa7b1a3e11505e737283cee36e7972b2081f9de28ec420607cd", + "bytes": 16578 + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "research/auxiliary-span-six-flag/README.md", + "sha256": "babb6e44c8ac7640a0cde329b7f6582e72adc2c9307de0d4b5bd2b2510489e1d", + "bytes": 16857 + } +] diff --git a/research/bit-three-active-one-returned/review/ENVIRONMENT-GUARD.json b/research/bit-three-active-one-returned/review/ENVIRONMENT-GUARD.json new file mode 100644 index 0000000000..0f8784af3e --- /dev/null +++ b/research/bit-three-active-one-returned/review/ENVIRONMENT-GUARD.json @@ -0,0 +1,6 @@ +{ + "status": "PASS_OPTIMIZED_ENVIRONMENT_CONTROL", + "parent": "-I -B with PYTHONOPTIMIZE=1", + "child_optimize": 0, + "child_debug": true +} diff --git a/research/bit-three-active-one-returned/review/FRACTION-TERMINALS.json b/research/bit-three-active-one-returned/review/FRACTION-TERMINALS.json new file mode 100644 index 0000000000..8ffd0c700b --- /dev/null +++ b/research/bit-three-active-one-returned/review/FRACTION-TERMINALS.json @@ -0,0 +1,4313 @@ +{ + "status": "PASS_FRACTION_TERMINAL_REPLAY", + "words": 538, + "nodes": 2152, + "terminals": 538, + "candidates": 0, + "records": [ + { + "word": 1041970, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041971, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041972, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041973, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041974, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041975, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041976, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041977, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041978, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041979, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041980, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041981, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041982, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041983, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041984, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041985, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041986, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041987, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041988, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041989, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041990, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041991, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041992, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041993, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041994, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041995, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041996, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041997, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041998, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041999, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042000, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042001, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042002, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042003, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042004, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042005, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042006, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042007, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042008, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042009, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042010, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042011, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051053, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051054, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051055, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051056, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051057, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051058, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051059, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051060, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051061, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051062, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051063, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051064, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051065, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051066, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051067, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051068, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051069, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051070, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051071, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051072, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051073, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051074, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051075, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051076, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051077, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051078, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051079, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051080, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051081, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051082, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051083, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051084, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051085, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051086, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051087, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051088, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051089, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051090, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051091, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051092, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051093, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051094, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051095, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051096, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051097, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051098, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051099, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051100, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051101, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051102, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051103, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057454, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057455, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057456, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057457, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057458, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057459, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057460, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057461, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057462, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057463, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057464, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057465, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057466, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057467, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057468, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057469, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057470, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057471, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057472, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057473, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057474, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057475, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057476, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057477, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057478, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057479, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057480, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057481, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057482, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057483, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057484, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057485, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057486, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057487, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057488, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057489, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057490, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057491, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057492, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057493, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057494, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057495, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062157, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062158, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062159, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062160, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062161, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062162, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062163, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062164, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062165, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062166, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062167, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062168, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062169, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062196, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062197, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062198, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062199, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062200, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062201, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062202, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062203, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062204, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062205, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062206, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062207, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068548, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068549, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068550, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068551, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068552, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068553, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068554, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068555, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068556, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068557, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068558, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068559, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068560, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068561, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068562, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068563, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068564, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068565, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068566, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068567, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068568, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068569, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068570, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068571, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068572, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068573, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074361, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074362, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074363, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074364, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074365, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074366, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074367, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074368, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074369, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074370, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074371, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074372, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074373, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074374, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074375, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074376, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074377, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074378, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074379, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074380, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074381, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074382, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074383, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074384, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074385, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074386, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074387, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074388, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074389, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074390, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074391, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074392, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074393, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074394, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074395, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074396, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074397, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074398, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074399, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074400, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074401, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074402, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074403, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074404, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074405, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074406, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074407, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074408, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074409, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074410, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074411, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081061, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081062, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081063, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081064, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081065, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081066, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081067, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081068, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081069, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081070, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081071, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081072, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081073, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081074, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081075, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081076, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081077, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081078, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081079, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081080, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081081, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081082, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081083, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081084, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081085, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081086, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081087, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081088, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081089, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081090, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081091, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081092, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081093, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081094, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081095, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087162, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087163, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087164, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087165, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087166, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087167, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087168, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087169, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087196, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087197, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087198, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087199, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087200, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087201, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087202, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087203, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087204, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087205, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087206, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087207, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087208, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087209, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087210, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087211, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087212, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094815, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094816, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094817, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094818, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094819, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094820, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094821, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094822, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094823, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094824, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094825, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094826, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094827, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094828, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094829, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094830, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094831, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094832, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094833, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094834, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094835, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094836, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094837, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094838, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094839, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094840, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100463, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100464, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100465, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100466, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100467, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100468, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100469, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100470, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100471, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100472, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100473, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100474, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100475, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100476, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100477, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100478, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100479, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100480, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100481, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100482, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100483, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100484, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100485, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100486, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100487, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100488, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100489, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100490, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100491, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100492, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100493, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100494, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100495, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100496, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100497, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100498, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100499, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100500, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100501, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100502, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100503, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100504, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100505, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100506, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100507, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100508, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100509, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100510, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100511, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100512, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100513, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106857, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106858, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106859, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106860, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106861, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106862, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106863, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106864, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106865, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106866, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106867, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106868, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106869, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106870, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106871, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106872, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106873, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106874, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106875, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106876, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106877, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106878, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106879, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106880, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106881, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106882, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106883, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106884, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106885, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106886, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106887, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106888, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106889, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106890, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106891, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112958, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112959, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112960, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112961, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112962, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112963, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112964, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112965, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112966, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112967, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112968, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112969, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112970, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112971, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112972, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112973, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112974, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112975, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112976, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112977, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112978, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112979, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112980, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112981, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112982, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112983, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112984, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112985, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112986, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112987, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112988, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112989, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112990, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112991, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112992, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112993, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112994, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112995, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112996, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112997, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112998, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112999, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113000, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113001, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113002, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113003, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113004, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113005, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113006, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113007, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113008, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + } + ] +} diff --git a/research/bit-three-active-one-returned/review/INDEPENDENT-REPLAY-RECEIPT.json b/research/bit-three-active-one-returned/review/INDEPENDENT-REPLAY-RECEIPT.json new file mode 100644 index 0000000000..192efa7cee --- /dev/null +++ b/research/bit-three-active-one-returned/review/INDEPENDENT-REPLAY-RECEIPT.json @@ -0,0 +1,83 @@ +{ + "status": "PASS_INDEPENDENT_RETURNED_REGISTER_FRONT_END", + "stages": [ + "catalogue", + "independent-catalogue", + "rank2-families", + "check_rank3_multisets-compile", + "check_rank3_orders-compile", + "rank2-multisets", + "rank3-multisets", + "input-binding", + "rank2-orders", + "rank3-orders", + "polynomial-controls" + ], + "reports": { + "OFF-CATALOGUE-RESULT.json": { + "status": "PASS_INDEPENDENT_OFF_PATTERN_CATALOGUE", + "projectors": 120, + "nonzero_off_patterns": 104, + "levels": [ + { + "dimension": 1, + "spaces": 104, + "strongly_connected_spaces": 0, + "classes": 0, + "representatives_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "eight_multisets": 0 + }, + { + "dimension": 2, + "spaces": 4964, + "strongly_connected_spaces": 634, + "classes": 45, + "representatives_sha256": "55a3766dbfeb7e83ffbeba2ac6f172d1a7c3eeb9653a2ee634f95ba82f85950b", + "eight_multisets": 61347 + }, + { + "dimension": 3, + "spaces": 140281, + "strongly_connected_spaces": 63567, + "classes": 2846, + "representatives_sha256": "83f52db23039b19bcaee7e94b05fd2b2c2033a3a41998c665aa5e6bdd537afc8", + "eight_multisets": 11210628 + } + ] + }, + "INPUT-BINDING-RESULT.json": { + "status": "PASS_CATALOGUE_MULTISET_WORD_BINARY_BINDING", + "pool_classes": 2846, + "multiset_rows": 4020, + "independent_multiset_rows": 4020, + "binary_records": 1901600, + "binary_bytes": 34228800, + "binary_sha256": "97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911" + }, + "RANK2-FRONT-END-RESULT.json": { + "status": "PASS_INDEPENDENT_RANK2_FRONT_END", + "families": 103, + "raw_orders": 831600, + "commutation_orders": 54294, + "reversal_orders": 27156, + "binary_word_and_role_stream_identical": true, + "binary_bytes": 488808, + "binary_sha256": "f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee" + }, + "RANK3-ORDERS-RESULT.json": { + "status": "PASS_INDEPENDENT_RANK3_ORDER_AND_QUOTIENT_REPLAY", + "families": 4020, + "raw_orders": 41706000, + "commutation_orders": 7121514, + "reversal_orders": 3560923, + "quotient_survivors": 1901600, + "binary_word_and_role_stream_identical": true + } + }, + "polynomial_controls": { + "formal_polynomial_controls": 7, + "passed": true, + "scope": "Formal polynomial core; these fixtures are not paid-call circuits." + }, + "source_manifest_sha256": "e67a75e9f09168f886223d10b93e0cf580c7e3ff45391c1719e67fccff541a54" +} diff --git a/research/bit-three-active-one-returned/review/PACKAGED-FRACTION-TERMINALS.json b/research/bit-three-active-one-returned/review/PACKAGED-FRACTION-TERMINALS.json new file mode 100644 index 0000000000..8ffd0c700b --- /dev/null +++ b/research/bit-three-active-one-returned/review/PACKAGED-FRACTION-TERMINALS.json @@ -0,0 +1,4313 @@ +{ + "status": "PASS_FRACTION_TERMINAL_REPLAY", + "words": 538, + "nodes": 2152, + "terminals": 538, + "candidates": 0, + "records": [ + { + "word": 1041970, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041971, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041972, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041973, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041974, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041975, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041976, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041977, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041978, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041979, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041980, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041981, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041982, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041983, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041984, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041985, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041986, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041987, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041988, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041989, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041990, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041991, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041992, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041993, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041994, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041995, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041996, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041997, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041998, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1041999, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042000, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042001, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042002, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042003, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042004, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042005, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042006, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042007, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042008, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042009, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042010, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1042011, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1046195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051053, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051054, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051055, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051056, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051057, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051058, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051059, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051060, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051061, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051062, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051063, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051064, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051065, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051066, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051067, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051068, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051069, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051070, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051071, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051072, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051073, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051074, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051075, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051076, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051077, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051078, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051079, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051080, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051081, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051082, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051083, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051084, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051085, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051086, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051087, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051088, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051089, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051090, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051091, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051092, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051093, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051094, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051095, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051096, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051097, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051098, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051099, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051100, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051101, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051102, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1051103, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057454, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057455, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057456, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057457, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057458, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057459, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057460, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057461, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057462, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057463, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057464, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057465, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057466, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057467, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057468, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057469, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057470, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057471, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057472, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057473, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057474, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057475, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057476, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057477, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057478, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057479, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057480, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057481, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057482, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057483, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057484, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057485, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057486, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057487, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057488, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057489, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057490, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057491, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057492, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057493, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057494, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1057495, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062157, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062158, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062159, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062160, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062161, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062162, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062163, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062164, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062165, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062166, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062167, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062168, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062169, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062196, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062197, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062198, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062199, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062200, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062201, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062202, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062203, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062204, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062205, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062206, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1062207, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068548, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068549, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068550, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068551, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068552, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068553, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068554, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068555, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068556, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068557, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068558, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068559, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068560, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068561, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068562, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068563, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068564, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068565, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068566, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068567, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068568, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068569, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068570, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068571, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068572, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1068573, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074361, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074362, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074363, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074364, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074365, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074366, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074367, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074368, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074369, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074370, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074371, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074372, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074373, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074374, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074375, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074376, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074377, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074378, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074379, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074380, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074381, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074382, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074383, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074384, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074385, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074386, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074387, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074388, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074389, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074390, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074391, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074392, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074393, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074394, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074395, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074396, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074397, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074398, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074399, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074400, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074401, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074402, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074403, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074404, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074405, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074406, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074407, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074408, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074409, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074410, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1074411, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081061, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081062, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081063, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081064, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081065, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081066, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081067, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081068, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081069, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081070, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081071, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081072, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081073, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081074, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081075, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081076, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081077, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081078, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081079, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081080, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081081, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081082, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081083, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081084, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081085, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081086, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081087, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081088, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081089, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081090, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081091, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081092, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081093, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081094, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1081095, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087162, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087163, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087164, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087165, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087166, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087167, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087168, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087169, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087170, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087171, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087172, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087173, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087174, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087175, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087176, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087177, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087178, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087179, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087180, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087181, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087182, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087183, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087184, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087185, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087186, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087187, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087188, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087189, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087190, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087191, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087192, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087193, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087194, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087195, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087196, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087197, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087198, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087199, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087200, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087201, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087202, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087203, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087204, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087205, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087206, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087207, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087208, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087209, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087210, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087211, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1087212, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094815, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094816, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094817, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094818, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094819, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094820, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094821, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094822, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094823, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094824, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094825, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094826, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094827, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094828, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094829, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094830, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094831, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094832, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094833, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094834, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094835, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094836, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094837, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094838, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094839, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1094840, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100463, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100464, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100465, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100466, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100467, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100468, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100469, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100470, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100471, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100472, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100473, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100474, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100475, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100476, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100477, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100478, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100479, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100480, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100481, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100482, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100483, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100484, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100485, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100486, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100487, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100488, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100489, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100490, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100491, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100492, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100493, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100494, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100495, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100496, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100497, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100498, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100499, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100500, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100501, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100502, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100503, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100504, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100505, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100506, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100507, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100508, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100509, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100510, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100511, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100512, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1100513, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106857, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106858, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106859, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106860, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106861, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106862, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106863, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106864, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106865, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106866, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106867, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106868, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106869, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106870, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106871, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106872, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106873, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106874, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106875, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106876, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106877, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106878, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106879, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106880, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106881, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106882, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106883, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106884, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106885, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106886, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106887, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106888, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106889, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106890, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1106891, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112958, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112959, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112960, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112961, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112962, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112963, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112964, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112965, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112966, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112967, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112968, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112969, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112970, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112971, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112972, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112973, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112974, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112975, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112976, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112977, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112978, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112979, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112980, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112981, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112982, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112983, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112984, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112985, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112986, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112987, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112988, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112989, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112990, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112991, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112992, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112993, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112994, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112995, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112996, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112997, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112998, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1112999, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113000, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113001, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113002, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113003, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113004, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113005, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113006, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113007, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + }, + { + "word": 1113008, + "nodes": 4, + "terminals": 1, + "low_rank_targets": 1, + "zero_frame_branches": 0, + "parity_branches": 0 + } + ] +} diff --git a/research/bit-three-active-one-returned/review/REPLAY-RECEIPT.json b/research/bit-three-active-one-returned/review/REPLAY-RECEIPT.json new file mode 100644 index 0000000000..cabb117814 --- /dev/null +++ b/research/bit-three-active-one-returned/review/REPLAY-RECEIPT.json @@ -0,0 +1,132 @@ +{ + "rank2": { + "multisets": 61347, + "families": 103, + "words": 27156 + }, + "rank3": { + "multisets": { + "classes": 2846, + "multisets": 11210628, + "distance_ok": 8623, + "rank_ok": 4020, + "irreducible": 4020 + }, + "orders": { + "families": 4020, + "prefixes": 28785353, + "commutation_orders": 7121514, + "reversal_orders": 3560923, + "parity_survivors": 1901600 + } + }, + "inputs": { + "2": { + "records": 27156, + "sha256": "f185daf27eb890d75698c14f8ce83e954fd2fc6ed07188908378fac44a2789ee" + }, + "3": { + "records": 1901600, + "sha256": "97ba623789da03fb0b83bc038d1e235691d96dcbb5c028ff72f0c108b2d71911" + } + }, + "engines": { + "2": { + "rational": { + "start": 0, + "end": 27156, + "states": [ + 27156, + 30618, + 8831, + 893 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 4087, + "zero_prunes": 30420 + }, + "field101": { + "words": 27156, + "states": [ + 27156, + 30618, + 6004, + 364 + ], + "terminals": 0, + "robust": 0, + "parity_prunes": 3786, + "zero_frame_prunes": 28791, + "nonmonomial_diagonal": 0, + "input_fnv64": 14983660685661952600 + }, + "terminal_word_agreement": true, + "chunk_agreement": true + }, + "3": { + "rational": { + "start": 0, + "end": 1901600, + "states": [ + 1901600, + 2034962, + 440516, + 54780 + ], + "terminals": 538, + "robust": 0, + "parity_prunes": 151674, + "zero_prunes": 1913504 + }, + "field101": { + "words": 1901600, + "states": [ + 1901600, + 2034962, + 456961, + 48892 + ], + "terminals": 538, + "robust": 0, + "parity_prunes": 154079, + "zero_frame_prunes": 1914429, + "nonmonomial_diagonal": 0, + "input_fnv64": 6871862008808761687 + }, + "terminal_word_agreement": true, + "chunk_agreement": true + } + }, + "catalogue": [ + { + "dimension": 1, + "spaces": 104, + "irreducible_spaces": 0, + "classes": 0 + }, + { + "dimension": 2, + "spaces": 4964, + "irreducible_spaces": 634, + "classes": 45 + }, + { + "dimension": 3, + "spaces": 140281, + "irreducible_spaces": 63567, + "classes": 2846 + } + ], + "source_sha256": { + "field101.cpp": "5995e8d4cfd7a212a083c4764d271cae15bf0baeb09b6b2897e2601065c02ed9", + "generate.py": "bf6e5ae35550ef01638e27c29dcfedaabcc4868d75d2d3f54383b4da4d9a5920", + "multisets.cpp": "dc508c03f0526aed029989e2d74c135f20be75b083124cc577ca218193d5666b", + "orders.cpp": "b2c0ebe347fcc7e3744b43e59c48b97ce1f70bdb786e900b8025dc9ab59af78a", + "rational.cpp": "590b838fd6662fb98464e1549bf23b862b2fae784984ccf419932bfe0b059c84", + "verify.py": "b889f5a43be0b404932b7b876fda82404a2ed0f6a4e9be34e81ec6b184ae3e95", + "verify_independent.py": "560d416e8f4a460b77bfa5595ffeaa2d17ab8f7579cc4412d8b948847073c263" + }, + "seconds": 163.3518979549408, + "status": "PASS_COMPLETE_FINITE_CHECKS" +} diff --git a/research/bit-three-active-one-returned/review/RESULT.json b/research/bit-three-active-one-returned/review/RESULT.json new file mode 100644 index 0000000000..63330b1bc2 --- /dev/null +++ b/research/bit-three-active-one-returned/review/RESULT.json @@ -0,0 +1,34 @@ +{ + "status": "PASS_NO_MATERIAL_FINDINGS", + "reviewer": "Separate OpenAI Codex agent; not human review", + "checked_files": 37, + "source_manifest_entries": 27, + "primary": { + "rank2_words": 27156, + "rank2_terminals": 0, + "rank3_words": 1901600, + "rank3_terminals": 538, + "accepted": 0, + "two_exact_engines": true + }, + "independent_front_end": { + "rank2_raw_orders": 831600, + "rank3_raw_orders": 41706000, + "full_stream_agreement": true + }, + "formal_polynomial_controls": 7, + "bounded_controls": 19, + "optimized_environment_control": "PASS after wrapper fix", + "fraction_terminal_words": 538, + "fraction_candidates": 0, + "packaged_fraction_optimization_rejected": true, + "review_sha256": "346ad317afbf9d54e62fa9064b6f370937783abd6a69f792ce8fe8e424cc0844", + "checked_manifest_sha256": "d1fb0034623120507ed485ddd903a33dfa9928de2e256e00956c9d080849f042", + "not_run": [ + "Full inherited PR468 finite search", + "Proof assistant verification", + "Physical supplier or kappa checks", + "GitHub PR rendering and final source URL checks (coordinator responsibility)" + ], + "final_prose_recheck": "README lineage narrowed to the common triangular-frame obstruction for PR203; executable and proof files unchanged." +} diff --git a/research/bit-three-active-one-returned/review/REVIEW.txt b/research/bit-three-active-one-returned/review/REVIEW.txt new file mode 100644 index 0000000000..0c847e8767 --- /dev/null +++ b/research/bit-three-active-one-returned/review/REVIEW.txt @@ -0,0 +1,191 @@ +Independent agent review: three active targets and one returned role +================================================================== + +Review scope +------------ +I reviewed the package bit-three-active-one-returned. This review is by a +separate OpenAI Codex agent. It is not human peer review or proof-assistant +verification. I read PR-DESCRIPTION-STANDARD.md before this report. + +The exact claim is a nine-call minimum in F_2[M_3(Q)] for three invertible +lower-triangular rational 3 by 3 targets and one arbitrary scalar role that +must return unchanged. The paid scalar projectors are binary rank-one +idempotents on four roles. Paid address frames are nonzero and have rational +rank one. The targets may differ. No numerator, denominator, alphabet, or +address-lattice parity bound is imposed. + +This is a scoped obstruction. It supplies no new supplier, physical circuit +price, multiplication exponent, or kappa improvement. It does not cover clean +workspace, more returned roles, arbitrary nontriangular target triples, or +noncommuting address operations. + +Proof review +------------ +1. Padding a shorter nonempty word by splitting A into A/2,A/2 is valid. + The two factors have the same projector, and idempotence gives the + original factor. All frames remain nonzero and rank one. +2. I read the span-four argument in the pinned PR468 proof. Its use of + target-minus-identity rank extends to the active-target count when a + returned target has frame zero. The common-ratio flag argument uses an + active invertible target. The zero frame remains zero in every block. + Thus eight calls require frame span at least five and relation rank at + most three. This step retains the lower-triangular hypothesis. +3. The invariant-subspace reduction handles equal active target characters. + Distinct formal coefficients force invariance under each coordinate + projection onto an equal-character space. A basis chosen within each + such space leaves the target diagonal. A rank-one idempotent in block + upper-triangular form has one nonzero diagonal block. The disjoint call + bounds are 3+6, or the retained three-register nine-call theorem. +4. The visible-distance bound is over Q. A functional can kill at most two + seen rank-one frames without killing an invertible target selected by the + row. This does not reduce rational matrix entries modulo two. The code + tests both rows and columns and the union of all returned roles. +5. The finitely generated group H of paid frames is free abelian. The kernel + of Z^8 onto H is saturated. Reduction modulo two is exact because H is + torsion-free. This justifies the derivative-space bound and the rank-three + finite quotient. It does not use augmentation of the divisible ambient + rational group. +6. The catalogue includes every binary rank-one idempotent in each pattern + space and all coordinate projectors. Their inclusion makes strong + connectivity equivalent to irreducibility of the full pool. Each used + support then gets its own invariant-subspace check. Coordinate + permutations preserve the domain because all returned roles are tested. +7. For two distinct rank-one idempotents, commutation is equivalent to both + cross contractions being zero. The normal forms use only these swaps. + Word reversal follows by inversion and the additive-address sign map; + it does not require symmetric projectors. +8. At a nonzero off-diagonal coefficient, every valid extension must merge + the chosen surviving exponent with another surviving exponent in the + same entry. Branching on every partner is complete. Already-cancelled + terms stay cancelled after further quotienting. Each new branch raises + rational relation rank, so depth three is enough. +9. A diagonal terminal has monomial entries because its determinant is a + monomial unit in a Laurent polynomial ring. Adding the exact returned + exponent as a relation is required; a binary parity test alone would + not suffice. A target in the relation space plus two coordinate units + lies in the rational span of two paid rank-one frames. This rejection + remains valid after every further relation, so terminal pruning is safe. +10. I checked the exact-arithmetic bounds. Every state has at most three + original cube rows; membership tests use at most four bounded nonunit + rows after coordinate rows are removed from minors. Their determinants + have absolute value at most 16, so reduction modulo 101 preserves rank. + The reconstructed RREF fractions have numerator and denominator at most + five in absolute value, with positive denominator. Cross differences + are at most 50, so their residues are distinct. Primitive row parities + are elements of the saturated relation lattice. The stated primitive + integer intermediate bounds are below signed 64-bit limits. +11. The nine-call upper bound uses each target's three nonzero column + matrices. Coordinate scalar projectors give the complete diagonal + endpoint and leave every column of the fourth input unchanged. + +No material finding remains in this scope. The result is suitable for +publication with the stated limits. No mathematical defect was found. The three-register finite +calculation inside PR468 is a retained dependency. I read its statement and +used written lemmas; I did not rerun that predecessor's full finite search. + +Fresh checks +------------ +The primary replay was run from the supplied source in a new directory: + +python3 -B work/project-final-cleanup-20261022/early-projects-audit/packages/bit-three-active-one-returned/verify.py --build /tmp/returned-register-independent-review-20261023 + +It passed with: + +Exact checks: 2 27156 0 0 +Exact checks: 3 1901600 538 0 + +The two engines agree on all terminal word IDs and all cumulative terminal +counts. Rank two has no diagonal terminal. Rank three has 538 terminals; +all are rejected. REPLAY-RECEIPT.json and replay.log retain this run. The +recorded wall time is 163.3518979549408 seconds, not a runtime bound. + +The independent front end was then run from its retained sources: + +python3 -B work/project-final-cleanup-20261022/early-projects-audit/packages/bit-three-active-one-returned/verify_independent.py --primary-build /tmp/returned-register-independent-review-20261023 --build /tmp/returned-register-independent-front-end-20261023 + +The independent source uses direct pattern combinations and permutation +orbits; support-first positive multiplicities and all 65 proper nonzero +subspaces; rank-two dependence signatures; and a full rank-three +next_permutation census with matrix-entry group-ring vectors. These differ +from the primary generation methods. The run passed. INDEPENDENT-REPLAY-RECEIPT.json records exact agreement +with the historical independent reports: 831600 raw rank-two orders, +41706000 raw rank-three orders, and both complete binary streams. The +seven formal-polynomial core controls also passed. Those fixtures are +not paid-call constructions. + +The separate bounded controls were run with: + +python3 -B work/project-final-cleanup-20261022/reviews/returned-register/controls.py work/project-final-cleanup-20261022/early-projects-audit/packages/bit-three-active-one-returned /tmp/returned-register-independent-review-20261023 work/project-final-cleanup-20261022/reviews/returned-register/CONTROLS.json + +All 19 controls passed. They test rejection of optimized Python, a changed +proof source, an occupied output folder, and malformed input records. They +also check every input column of a nine-call word for three different +lower-triangular targets, all nine deleted-call mutations, and a changed +returned-role endpoint. These controls do not prove the lower bound. + +The Fraction terminal replay was also run from the retained Python source: + +python3 -B work/project-final-cleanup-20261022/reviews/returned-register/fraction_terminals.py work/project-final-cleanup-20261022/early-projects-audit/packages/bit-three-active-one-returned /tmp/returned-register-independent-review-20261023 work/project-final-cleanup-20261022/reviews/returned-register/FRACTION-TERMINALS.json + +It checks all 538 terminal word IDs from the fresh primary run. It reaches +538 terminals and zero candidates. Every per-word node, terminal, and +rejection count agrees with the historical fraction-terminal-audit.json. +This is an extra arithmetic check on terminal words, not a third full +classification of all rejected words. + +Overlap and provenance +---------------------- +I checked the relevant public packages at main commit +cef4b52f2a59009865bf8eabde1be3f159063703 and searched the 315 open PR metadata +records in OPEN-PRS.json. I found no duplicate of this exact theorem. + +PR468 covers exactly three scalar roles. The later no-target-flag theorem +removes triangularity for three roles only. The dirty-auxiliary theorem +settles two active targets and the at-most-one-relation domain. The +identical-target and parity-uniform results allow more returned roles but +restrict the target classes. Mixed-target compression limits the number of +roles of a possible word but does not exclude it. The span-six flag and +span-four structural packages leave cases open or use a different endpoint. +Finite dyadic and odd-denominator results restrict the frame or target +lattice. None of these covers the present unrestricted rational frames, +three lower-triangular targets, and one returned role in full. + +The package credits PR468 and its PR288 and PR203 lineage. The pinned PR468 +source explicitly supplies those predecessor credits. PR288 supplies the +compact-product projection/flag bound. PR203 supplies the related common +triangular-frame obstruction; its proof uses a communication argument. The package identifies +Codex and agent work and does not claim human review. The full source and +proof pin list is in DEPENDENCY-AND-OVERLAP-PINS.json. The coordinator must +still validate the final PR's GitHub URLs, rendered body, and readback. + +Resolved packaging findings +--------------------------- +The first package retained historical independent receipts without the +source of their separate front-end checks. The packaging worker added the +small independent sources, their dependencies, the original model/arithmetic +notes, and a driver that rebuilds the needed inputs. The byte-level source +manifest binds those additions. The package also keeps the historical +Fraction terminal receipt and the short terminal-replay driver. The updated README also states the modern +overlap boundary and the predecessor method credit. + +The historical polynomial-control script calls clang++ directly. The +README now states that prerequisite. CXX selects the main compiler but +does not select the compiler for that unchanged historical control. + +A separate environment control reproduced an assertion-guard defect in +the first wrappers. An isolated parent could ignore PYTHONOPTIMIZE while +its child inherited that variable. Both wrappers now pass -E -B to all +Python child commands. The control passes: child optimize is zero and +__debug__ is true even with parent isolation and PYTHONOPTIMIZE=1. An AST +check found the flags at all seven Python child command sites. No historical +mathematical source changed. The completed full runs used an unoptimized +parent without isolation, so this defect did not affect those runs. + +python3 -B work/project-final-cleanup-20261022/reviews/returned-register/environment_guard.py work/project-final-cleanup-20261022/early-projects-audit/packages/bit-three-active-one-returned work/project-final-cleanup-20261022/reviews/returned-register/ENVIRONMENT-GUARD.json + +Final file binding +------------------ +CHECKED-FILES.json binds the package files checked by this review. Changes +that affect proof or executable behavior after that manifest require a +focused rereview. A later copy of this review into the package is not an +additional proof dependency. diff --git a/research/bit-three-active-one-returned/review/WRAPPER-FINDING.json b/research/bit-three-active-one-returned/review/WRAPPER-FINDING.json new file mode 100644 index 0000000000..bceda960e7 --- /dev/null +++ b/research/bit-three-active-one-returned/review/WRAPPER-FINDING.json @@ -0,0 +1,11 @@ +{ + "finding": "Isolated parent could pass PYTHONOPTIMIZE to a child with historical assertions.", + "reproduction": "environment_guard.py on the pre-fix verify.py", + "before": { + "exit_code": 0, + "child_optimize": 1, + "child_debug": false + }, + "requested_fix": "Use -E for each Python child; preserve script-directory imports.", + "historical_proof_sources_changed": false +} diff --git a/research/bit-three-active-one-returned/review/controls.py b/research/bit-three-active-one-returned/review/controls.py new file mode 100644 index 0000000000..603ac97c0f --- /dev/null +++ b/research/bit-three-active-one-returned/review/controls.py @@ -0,0 +1,76 @@ +"""Independent bounded checks for the returned-register package.""" +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +PACKAGE = Path(sys.argv[1]).resolve() +BUILD = Path(sys.argv[2]).resolve() +RESULT = Path(sys.argv[3]).resolve() +checks = [] + +def require(value, label): + if not value: + raise RuntimeError(label) + checks.append(label) + +def run_reject(command, message): + result = subprocess.run(command, capture_output=True, text=True) + require(result.returncode != 0 and message in result.stdout + result.stderr, message) + +with tempfile.TemporaryDirectory(prefix="returned-register-controls-") as temp: + tmp = Path(temp) + run_reject([sys.executable, "-O", "-B", str(PACKAGE / "verify.py"), "--build", str(tmp / "optimized")], "Run this verifier without -O") + require(not (tmp / "optimized").exists(), "optimized mode rejects before creating output") + occupied = tmp / "occupied" + occupied.mkdir() + (occupied / "sentinel").write_bytes(b"retained") + run_reject([sys.executable, "-B", str(PACKAGE / "verify.py"), "--build", str(occupied)], "FileExistsError") + require((occupied / "sentinel").read_bytes() == b"retained", "occupied output is unchanged") + copy = tmp / "package" + copy.mkdir() + for item in PACKAGE.iterdir(): + if item.is_file(): + shutil.copy2(item, copy / item.name) + with (copy / "PROOF.txt").open("ab") as out: + out.write(b"\nmutation\n") + run_reject([sys.executable, "-B", str(copy / "verify.py"), "--build", str(tmp / "mutated")], "Source hash: PROOF.txt") + require(not (tmp / "mutated").exists(), "source mutation rejects before creating output") + bad = tmp / "bad.bin" + bad.write_bytes(b"x") + run_reject([str(BUILD / "rational"), str(bad), str(tmp / "rational"), "dirty"], "Invalid input length") + run_reject([str(BUILD / "field101"), str(bad), str(tmp / "field.jsonl")], "Input size is not divisible by 18") + +# Propagate each input column through actual address shifts. This does not +# use either collision engine or its formal matrix expansion. +ZERO = (0,) * 9 +TARGETS = [(1,0,0,2,3,0,4,5,7), (2,0,0,-1,5,0,6,4,3), (3,0,0,7,2,0,-2,9,5)] +word = [] +for role, target in enumerate(TARGETS): + for column in range(3): + frame = tuple(target[3*i+j] if j == column else 0 for i in range(3) for j in range(3)) + word.append((role, frame)) + +def endpoint(calls): + columns = [] + for source in range(4): + state = [{ZERO} if i == source else set() for i in range(4)] + for role, frame in calls: + state[role] = {tuple(a+b for a,b in zip(exponent, frame)) for exponent in state[role]} + columns.append(state) + return columns + +expected = [[{TARGETS[i] if i < 3 else ZERO} if i == j else set() for i in range(4)] for j in range(4)] +require(endpoint(word) == expected, "nine calls realize three different lower triangular targets and all four input columns") +for omitted in range(9): + require(endpoint(word[:omitted] + word[omitted+1:]) != expected, "omitted call " + str(omitted) + " changes the endpoint") +wrong_dirty = [row.copy() for row in expected] +wrong_dirty[3][3] = {TARGETS[0]} +require(endpoint(word) != wrong_dirty, "changed returned-role endpoint is rejected") + +RESULT.write_text(json.dumps({"status": "PASS_BOUNDED_INDEPENDENT_CONTROLS", "checks": checks}, indent=2) + "\n") +print(len(checks), "controls passed") diff --git a/research/bit-three-active-one-returned/review/environment_guard.py b/research/bit-three-active-one-returned/review/environment_guard.py new file mode 100644 index 0000000000..7f04065280 --- /dev/null +++ b/research/bit-three-active-one-returned/review/environment_guard.py @@ -0,0 +1,24 @@ +"""Check that the wrapper does not pass Python optimization to its child.""" +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile + +package = Path(sys.argv[1]).resolve() +output = Path(sys.argv[2]).resolve() +with tempfile.TemporaryDirectory(prefix='returned-register-env-control-') as directory: + root = Path(directory) + shutil.copy2(package / 'verify.py', root / 'verify.py') + script = root / 'generate.py' + script.write_text('import sys\nprint(sys.flags.optimize)\nprint(__debug__)\n') + (root / 'SOURCE-MANIFEST.json').write_text(json.dumps({'files':[{'package':'generate.py','sha256':hashlib.sha256(script.read_bytes()).hexdigest()}]})) + env = dict(os.environ, PYTHONOPTIMIZE='1') + result = subprocess.run([sys.executable,'-I','-B',str(root/'verify.py')],env=env,text=True,capture_output=True) + if result.returncode != 0 or result.stdout != '0\nTrue\n': + raise RuntimeError('Python optimization reached child: ' + repr((result.returncode,result.stdout,result.stderr))) +output.write_text(json.dumps({'status':'PASS_OPTIMIZED_ENVIRONMENT_CONTROL','parent':'-I -B with PYTHONOPTIMIZE=1','child_optimize':0,'child_debug':True},indent=2)+'\n') +print('Parent isolation does not expose child to PYTHONOPTIMIZE.') diff --git a/research/bit-three-active-one-returned/review/fraction_terminals.py b/research/bit-three-active-one-returned/review/fraction_terminals.py new file mode 100644 index 0000000000..302cd4d718 --- /dev/null +++ b/research/bit-three-active-one-returned/review/fraction_terminals.py @@ -0,0 +1,41 @@ +"""Replay the complete set of retained diagonal terminal words with Fraction.""" +from importlib.util import module_from_spec, spec_from_file_location +import json +from pathlib import Path +import struct +import sys + +package, primary, output = map(Path, sys.argv[1:]) +source = package / 'independent-sources/work/four-register/dirty_ancilla.py' +spec = spec_from_file_location('fraction_core', source) +core = module_from_spec(spec) +spec.loader.exec_module(core) +terminals = [json.loads(line) for line in (primary / 'rational3.terminals.jsonl').read_text().splitlines()] +if len(terminals) != 538 or len({r['word'] for r in terminals}) != 538: + raise RuntimeError('Terminal word count') +records = [] +with (primary / 'rank3.bin').open('rb') as inp: + for record in terminals: + inp.seek(18 * record['word']) + matrices = struct.unpack('<9H', inp.read(18))[:8] + word = [] + for matrix in matrices: + rows = [(matrix >> (4*i)) & 15 for i in range(4)] + nonzero = {r for r in rows if r} + if len(nonzero) != 1: + raise RuntimeError('Projector rank') + y = next(iter(nonzero)) + x = sum(1 << i for i,r in enumerate(rows) if r) + if (x & y).bit_count() % 2 != 1: + raise RuntimeError('Projector idempotence') + word.append((x,y)) + result = core.solve(word) + if result['candidate'] or result['stats']['terminals'] != record['terminals']: + raise RuntimeError('Fraction terminal result') + stats = result['stats'] + records.append({'word': record['word'], **{key: stats[key] for key in ['nodes','terminals','low_rank_targets','zero_frame_branches','parity_branches']}}) + core.rref.cache_clear() + core.rep.cache_clear() + core.add.cache_clear() +output.write_text(json.dumps({'status':'PASS_FRACTION_TERMINAL_REPLAY','words':len(records),'nodes':sum(r['nodes'] for r in records),'terminals':sum(r['terminals'] for r in records),'candidates':0,'records':records},indent=2)+'\n') +print('538 terminal words, 538 terminals, zero candidates') diff --git a/research/bit-three-active-one-returned/review/independent-replay.log b/research/bit-three-active-one-returned/review/independent-replay.log new file mode 100644 index 0000000000..b3bcbc3d75 --- /dev/null +++ b/research/bit-three-active-one-returned/review/independent-replay.log @@ -0,0 +1,12 @@ +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent/off_pattern_spaces.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_off_catalogue.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /private/tmp/returned-register-independent-front-end-20261023/work/four-register/dirty_rank2.py +Run: /usr/bin/clang++ -O3 -std=c++17 /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_multisets.cpp -o /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_multisets +Run: /usr/bin/clang++ -O3 -std=c++17 /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_orders.cpp -o /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_orders +Run: /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_multisets /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/rank2-pools.txt 2 +Run: /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_multisets /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent/rank3-pools.txt +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_input_binding.py +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank2_orders.py +Run: /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent-audit/check_rank3_orders /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent/rank3-word-input.txt /private/tmp/returned-register-independent-front-end-20261023/work/four-register/independent/rank3-words.bin +Run: /opt/homebrew/opt/python@3.14/bin/python3.14 -B /private/tmp/returned-register-independent-front-end-20261023/work/four-register/dirty_f101_controls.py +PASS_INDEPENDENT_RETURNED_REGISTER_FRONT_END diff --git a/research/bit-three-active-one-returned/review/replay.log b/research/bit-three-active-one-returned/review/replay.log new file mode 100644 index 0000000000..84dd2f33c0 --- /dev/null +++ b/research/bit-three-active-one-returned/review/replay.log @@ -0,0 +1,6 @@ +Catalogue: 1 104 0 0 +Catalogue: 2 4964 634 45 +Catalogue: 3 140281 63567 2846 +Exact checks: 2 27156 0 0 +Exact checks: 3 1901600 538 0 +Receipt: /private/tmp/returned-register-independent-review-20261023/receipt.json diff --git a/research/bit-three-active-one-returned/verify.py b/research/bit-three-active-one-returned/verify.py new file mode 100644 index 0000000000..6760d63a94 --- /dev/null +++ b/research/bit-three-active-one-returned/verify.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python3 +"""Run the saved complete verifier with its assertions enabled.""" +import hashlib +import json +from pathlib import Path +import subprocess +import sys + +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +root = Path(__file__).resolve().parent +manifest = json.loads((root / "SOURCE-MANIFEST.json").read_text()) +for item in manifest["files"]: + actual = hashlib.sha256((root / item["package"]).read_bytes()).hexdigest() + if actual != item["sha256"]: + raise SystemExit("Source hash: " + item["package"]) +subprocess.run([sys.executable, "-E", "-B", str(root / "generate.py"), *sys.argv[1:]], check=True) diff --git a/research/bit-three-active-one-returned/verify_fraction_terminals.py b/research/bit-three-active-one-returned/verify_fraction_terminals.py new file mode 100644 index 0000000000..449938acc5 --- /dev/null +++ b/research/bit-three-active-one-returned/verify_fraction_terminals.py @@ -0,0 +1,44 @@ +"""Replay the complete set of retained diagonal terminal words with Fraction.""" +from importlib.util import module_from_spec, spec_from_file_location +import json +from pathlib import Path +import struct +import sys + +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") + +package, primary, output = map(Path, sys.argv[1:]) +source = package / 'independent-sources/work/four-register/dirty_ancilla.py' +spec = spec_from_file_location('fraction_core', source) +core = module_from_spec(spec) +spec.loader.exec_module(core) +terminals = [json.loads(line) for line in (primary / 'rational3.terminals.jsonl').read_text().splitlines()] +if len(terminals) != 538 or len({r['word'] for r in terminals}) != 538: + raise RuntimeError('Terminal word count') +records = [] +with (primary / 'rank3.bin').open('rb') as inp: + for record in terminals: + inp.seek(18 * record['word']) + matrices = struct.unpack('<9H', inp.read(18))[:8] + word = [] + for matrix in matrices: + rows = [(matrix >> (4*i)) & 15 for i in range(4)] + nonzero = {r for r in rows if r} + if len(nonzero) != 1: + raise RuntimeError('Projector rank') + y = next(iter(nonzero)) + x = sum(1 << i for i,r in enumerate(rows) if r) + if (x & y).bit_count() % 2 != 1: + raise RuntimeError('Projector idempotence') + word.append((x,y)) + result = core.solve(word) + if result['candidate'] or result['stats']['terminals'] != record['terminals']: + raise RuntimeError('Fraction terminal result') + stats = result['stats'] + records.append({'word': record['word'], **{key: stats[key] for key in ['nodes','terminals','low_rank_targets','zero_frame_branches','parity_branches']}}) + core.rref.cache_clear() + core.rep.cache_clear() + core.add.cache_clear() +output.write_text(json.dumps({'status':'PASS_FRACTION_TERMINAL_REPLAY','words':len(records),'nodes':sum(r['nodes'] for r in records),'terminals':sum(r['terminals'] for r in records),'candidates':0,'records':records},indent=2)+'\n') +print('538 terminal words, 538 terminals, zero candidates') diff --git a/research/bit-three-active-one-returned/verify_independent.py b/research/bit-three-active-one-returned/verify_independent.py new file mode 100644 index 0000000000..8526595bba --- /dev/null +++ b/research/bit-three-active-one-returned/verify_independent.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +"""Replay the independent front end against a complete primary build.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import sys + +if not __debug__: + raise SystemExit("Run this verifier without -O. Historical sources use assert.") +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--primary-build", type=Path, required=True) + parser.add_argument("--build", type=Path, required=True) + args = parser.parse_args() + primary, build = args.primary_build.resolve(), args.build.resolve() + require(not build.exists(), "The build directory exists.") + manifest = json.loads((ROOT / "SOURCE-MANIFEST.json").read_text()) + for item in manifest["files"]: + require(hashlib.sha256((ROOT / item["package"]).read_bytes()).hexdigest() + == item["sha256"], "Source hash: " + item["package"]) + receipt = json.loads((primary / "receipt.json").read_text()) + require(receipt["status"] == "PASS_COMPLETE_FINITE_CHECKS", "Primary status") + for rank in [2, 3]: + require(hashlib.sha256((primary / f"rank{rank}.bin").read_bytes()).hexdigest() + == receipt["inputs"][str(rank)]["sha256"], "Primary input hash") + shutil.copytree(ROOT / "independent-sources", build) + base = build / "work/four-register" + source, audit = base / "independent", base / "independent-audit" + compiler = os.environ.get("CXX") or shutil.which("clang++") or shutil.which("g++") + require(compiler is not None, "A C++17 compiler is required.") + stages = [] + def run(label, command, output=None): + print("Run:", " ".join(map(str, command)), flush=True) + target = output or build / (label + ".stdout.log") + with target.open("w") as out, (build / (label + ".stderr.log")).open("w") as err: + subprocess.run(list(map(str, command)), cwd=build, check=True, + stdout=out, stderr=err) + stages.append(label) + run("catalogue", [sys.executable, "-E", "-B", source / "off_pattern_spaces.py"]) + run("independent-catalogue", [sys.executable, "-E", "-B", audit / "check_off_catalogue.py"]) + run("rank2-families", [sys.executable, "-E", "-B", base / "dirty_rank2.py"]) + levels = json.loads((source / "off-pattern-spaces.json").read_text())["levels"] + with (audit / "rank2-pools.txt").open("w") as out: + pools = levels[1]["representatives"] + out.write(str(len(pools)) + "\n") + for pool in pools: + out.write(str(len(pool["projectors"])) + "\n") + for x, y in pool["projectors"]: + matrix = sum(y << (4 * i) for i in range(4) if x >> i & 1) + out.write(f"{x} {y} {pool['space'].index(matrix & 0x7bde)}\n") + for original, destination in [("pools.txt", "rank3-pools.txt"), + ("multisets.jsonl", "rank3-multisets.jsonl"), + ("orders.txt", "rank3-word-input.txt"), + ("orders.jsonl", "rank3-parity-survivors.jsonl"), + ("rank2.bin", "rank2-words.bin"), + ("rank3.bin", "rank3-words.bin")]: + shutil.copyfile(primary / original, source / destination) + for name in ["check_rank3_multisets", "check_rank3_orders"]: + run(name + "-compile", [compiler, "-O3", "-std=c++17", audit / (name + ".cpp"), + "-o", audit / name]) + run("rank2-multisets", [audit / "check_rank3_multisets", audit / "rank2-pools.txt", "2"], + audit / "rank2-multisets.jsonl") + run("rank3-multisets", [audit / "check_rank3_multisets", source / "rank3-pools.txt"], + audit / "rank3-multisets.jsonl") + run("input-binding", [sys.executable, "-E", "-B", audit / "check_input_binding.py"]) + run("rank2-orders", [sys.executable, "-E", "-B", audit / "check_rank2_orders.py"]) + run("rank3-orders", [audit / "check_rank3_orders", source / "rank3-word-input.txt", + source / "rank3-words.bin"], audit / "RANK3-ORDERS-RESULT.json") + shutil.copyfile(ROOT / "field101.cpp", base / "dirty_f101.cpp") + run("polynomial-controls", [sys.executable, "-E", "-B", base / "dirty_f101_controls.py"]) + expected = json.loads((ROOT / "independent-receipt.json").read_text()) + reports = {name: json.loads((audit / name).read_text()) for name in + ["OFF-CATALOGUE-RESULT.json", "INPUT-BINDING-RESULT.json", + "RANK2-FRONT-END-RESULT.json", "RANK3-ORDERS-RESULT.json"]} + old_reports = expected["independent_receipts"] + for name, value in reports.items(): + require(value == old_reports[name], "Independent report: " + name) + final = {"status": "PASS_INDEPENDENT_RETURNED_REGISTER_FRONT_END", "stages": stages, + "reports": reports, "polynomial_controls": json.loads((base / "dirty-f101-controls.json").read_text()), + "source_manifest_sha256": hashlib.sha256((ROOT / "SOURCE-MANIFEST.json").read_bytes()).hexdigest()} + (build / "receipt.json").write_text(json.dumps(final, indent=2) + "\n") + print(final["status"]) + + +if __name__ == "__main__": + main()