diff --git a/research/bit-completed-backend-api/.gitattributes b/research/bit-completed-backend-api/.gitattributes new file mode 100644 index 0000000000..3681979f27 --- /dev/null +++ b/research/bit-completed-backend-api/.gitattributes @@ -0,0 +1,4 @@ +science/** -text +independent/** -text +written-review/** -text +proposal/** -text diff --git a/research/bit-completed-backend-api/BUDGET.md b/research/bit-completed-backend-api/BUDGET.md new file mode 100644 index 0000000000..e2d2b15230 --- /dev/null +++ b/research/bit-completed-backend-api/BUDGET.md @@ -0,0 +1,9 @@ +# Retained bill and conditional cost boundary + +No raw rank/profile changes:4760 retains11400 original owners,57339 paid queries,7848 global helper originals and436 independent local helpers. All9rank7 COPY episodes per local FULL remain charged. The72 partial rank4 outputs require144 added matcher routes;7548 other raw routes remain, total7692 RAW routes, not a final compiled count. + +The selected8-dimensional matcher has5swaps,5unit scales and14shears. Applying each factor on all8 complete high rows gives40/40/112 elementary operations per direction. At most64 carry translations plus one finite low-type permutation are also paid per direction. Thus the matcher pair has80 ordinary swaps,80scales,224linear shifts,≤128carry shifts and2low-type permutations. No f factor is missing: f is column multiplicity, while the coarse cover dimension is fixed. Larger fixed N requires a newly fixed finite bound. Low-type tables and rational descriptors are physical routing assumptions with paid finite costs, not free oracle access. + +Weighted unit leaves use4older ordinary swaps+3controlled shifts+1sign. The ordinary wrapper uses2completed raw bodies+3additions outside the stopped recurrence; its multiplicity is not inserted into every characteristic branch. High stock is O(w log e), internally borrowed and restored. Initialization, owned allocation, erasure, ROW/radix padding/removal, full delayed-cover fallback and tape/precision/outer costs remain charged or retained assumptions as stated in P1–P3. + +The existing rho=.01, C1=.00347545805−(2^-36+10^-20), b0=.0034597 stage gaps are checked, not retuned. Only constructively bounded finite constants and stated lower-order terms are absorbed at a new fixed threshold. Unknown asymptotic operations cannot be absorbed. No new κ, raw crossing, unpaid owner or independent full primitive implementation follows. diff --git a/research/bit-completed-backend-api/HANDOFF.md b/research/bit-completed-backend-api/HANDOFF.md new file mode 100644 index 0000000000..46a1ade811 --- /dev/null +++ b/research/bit-completed-backend-api/HANDOFF.md @@ -0,0 +1,15 @@ +HANDOFF + +Research discussion / PR / artifact: LOCAL-ONLY package research/bit-completed-backend-api; canonical investigation https://github.com/CrocSwap/integer-mult-bounds/discussions/4945. No new PR is asserted before publication. + +Exact commit: LOCAL-ONLY working package based on canonical cef4b52f2a59009865bf8eabde1be3f159063703; the publication handoff must substitute the actual final head. + +What is established: Conditional first4760 A0→4814 A1 completed ordinary API implication, with actual helper462/frame506, all-width written argument, paid route ledger and corrected22fixture/384column finite corroboration. Separate source/operator and written reviews pass within P1–P3. + +What remains uncertain: Actual all-width raw/native/compiler ROW/owner implementation, physical routing/tape/precision, analytic/outer recovery and finite machine constants remain inherited. Full actual_backend_API is not independently verified; no new κ or complete caller follows. + +Smallest useful next task: Emit one literal fixed N-dimensional physical stock/role/route invocation satisfying P1–P3, with restored ROW, distinct owners, paid fallback and tape/precision ledger; retain the current conditional admission boundary until checked. + +Reproduction command and expected runtime: python3 -I -W error -B research/bit-completed-backend-api/verify.py author; replace author by independent or controls. Normal/O modes are registered in VERIFY.json; each bounded to90seconds, standard-library Python3.12, Git-free direct export replay. + +Predecessor credit: ai-nanachi4760/4814/4326; rohanarun185/199, Maxime Fleury204, Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612 and retained native/ordinary/ROW/delayed-cover/precision/tape/outer lineage. Substantial OpenAI Codex assistance, Apache-2.0, no human/formal-kernel review. diff --git a/research/bit-completed-backend-api/LICENSE b/research/bit-completed-backend-api/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/bit-completed-backend-api/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/bit-completed-backend-api/ORIGINS.json b/research/bit-completed-backend-api/ORIGINS.json new file mode 100644 index 0000000000..8b30ddceaf --- /dev/null +++ b/research/bit-completed-backend-api/ORIGINS.json @@ -0,0 +1,74 @@ +{ + "source_heads": [ + "ecdfcabd56dfa663ae020733f9f1a88c6644743c", + "f56ae4533a7d97d782a2c596a33fe844cd051747" + ], + "canonical_base": "cef4b52f2a59009865bf8eabde1be3f159063703", + "sources": [ + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "notes/three-stage-cover-bit.tex", + "retained_path": "independent/inputs/three-stage-cover-bit.tex", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "same_bytes_at_4760": true + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "notes/three-stage-cover-rows.tex", + "retained_path": "independent/inputs/three-stage-cover-rows.tex", + "git_blob": "590da4b892a08b9d5182fb3d8a983c6239dd27db", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "same_bytes_at_4760": true + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz", + "retained_path": "independent/inputs/WORD.json.gz", + "git_blob": "776ddd13d67b2259e90d39de5b42e4df4b1447f1", + "sha256": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "same_bytes_at_4760": true + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "research/bit-finite-ordinary-bootstrap/PROOF.md", + "retained_path": "independent/inputs/PROOF.md", + "git_blob": "7db6805f8a9ae77b28c5772ee6de3e47777912b1", + "sha256": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "same_bytes_at_4760": false + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "research/bit-finite-ordinary-bootstrap/RECORD.json", + "retained_path": "independent/inputs/RECORD.json", + "git_blob": "3c8934f23e3d58d8ad5bcfb0abd58b44810a994d", + "sha256": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "same_bytes_at_4760": false + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "research/bit-finite-ordinary-bootstrap/independent.py", + "retained_path": "independent/inputs/independent.py", + "git_blob": "498ebb37a3408fc0292e183a6e11490109b604d2", + "sha256": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "same_bytes_at_4760": false + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "retained_path": "independent/inputs/DELAYED-COVER-BRIDGE.md", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "same_bytes_at_4760": true + }, + { + "original_commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "original_path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "retained_path": "independent/inputs/frames.json", + "git_blob": "a9a932b9268da28af9ba4bccdab205c5bcd50ad3", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010", + "same_bytes_at_4760": true + } + ], + "all_source_heads_ancestral_to_canonical_base": true +} diff --git a/research/bit-completed-backend-api/PACKET.json b/research/bit-completed-backend-api/PACKET.json new file mode 100644 index 0000000000..a9dd800faa --- /dev/null +++ b/research/bit-completed-backend-api/PACKET.json @@ -0,0 +1,58 @@ +{ + "files": { + "independent/CONTROL-CORRECTION.diff": "9503b93115e59028f56e632b02fdd0263c80af925177aa117f73056e21531c2b", + "independent/CORRECTED-HASHES.json": "e6900604c89d331731f3fcb4f01c1c36c16d67f5ae08404e370ddd9b119b3d1c", + "independent/FILES.json": "d1a7d9e9093097c1695198c9c1937ddb4e8ad4a9c1c28c68c0d859003a49068b", + "independent/FROZEN-HASHES.json": "65ab2038c80471498087124fedb196346cdf3975101c86feafc30d4de6cc6241", + "independent/INDEPENDENT.json": "7818430484073c50aa50e4ded758d2acc0faf556c9f98ae7c91420269260fdab", + "independent/REVIEW.md": "43c9d67d6eb6965ab304b42af4e07fccdba9843ee00995656014bee53746579a", + "independent/RUNS.json": "3b126e460ac1e9af21f36ccd43cef90a80d883139503f4e287175faf84ec99d3", + "independent/SOURCE-BINDING.json": "7f99637e46607dbcfa950767b17607bf8acc50d7379b02d6a95ef3cbb5bc4d7b", + "independent/corrected/PROOF.md": "61d40f649f0afc6116c05dbe370323dd5f38849214d37eb983a4101410818b0b", + "independent/corrected/REPORT.md": "45971605fa01dd3fd1b54f8fb22809f7e5c635995d0640bafc0be29e567fb9f7", + "independent/corrected/RESULT.json": "965b650c0e49572e028f89a60943c64ad8dff9032fc93272b86cd1f9715a77b7", + "independent/corrected/SOURCES.json": "66a167a1aa14427403c65bb00d8fdcbca33166c3e0f60e8c6d1688f6f6d69b25", + "independent/corrected/check.py": "0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e", + "independent/corrected/normal.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "independent/corrected/optimized.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "independent/frozen/PROOF.md": "d4113c38bff4c5e2179b445f71db988145c2cee6d8ddea80e9812c0cf659f11c", + "independent/frozen/REPORT.md": "216d40345fda1566db5e338b9018d1f5b29e8586ca9b55468645ca826fe131f6", + "independent/frozen/RESULT.json": "8d376a1662e1a982d744cc3904d3ae6c6881abe820710cfd7aec7166724bffda", + "independent/frozen/SOURCES.json": "952e2054af965e34ebcaf1e37e3fd4bbcffdc6b734fcd9acc68175f5991ede59", + "independent/frozen/check.py": "1cd0967b2149a286f440efe6e7249ff1bdd32b0b8413036e6767dc30bc13d4b7", + "independent/independent-normal.log": "7818430484073c50aa50e4ded758d2acc0faf556c9f98ae7c91420269260fdab", + "independent/independent-optimized.log": "7818430484073c50aa50e4ded758d2acc0faf556c9f98ae7c91420269260fdab", + "independent/independent.py": "4bd2d0551886e288b8802070b85c09ea81632fe9196227cde9ae87b9f797dce3", + "independent/inputs/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "independent/inputs/PROOF.md": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "independent/inputs/RECORD.json": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "independent/inputs/WORD.json.gz": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "independent/inputs/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010", + "independent/inputs/independent.py": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "independent/inputs/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "independent/inputs/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "proposal/CLAIM-DRAFT.md": "53c402147f962c60951dd1d56cff2acc4f6ecac0f9d7d8de35025adf9227220e", + "proposal/EXPERIMENT-PROPOSAL.md": "f4f6b6232760b3fbce7997d55c79bd3a05b7308e94ca3b1448537398f4573131", + "proposal/SOURCES.json": "adf737d4236aecc58580fedbee01c44c016ca3c13b09c46ae69de5f1b2afd968", + "proposal/TASK-PROPOSAL.json": "8ac7887b841741fe746a0e03c03573f3eb7c3fe9dd024c7eb763f8b549b1e37d", + "science/PROOF.md": "61d40f649f0afc6116c05dbe370323dd5f38849214d37eb983a4101410818b0b", + "science/REPORT.md": "45971605fa01dd3fd1b54f8fb22809f7e5c635995d0640bafc0be29e567fb9f7", + "science/RESULT.json": "965b650c0e49572e028f89a60943c64ad8dff9032fc93272b86cd1f9715a77b7", + "science/SOURCES.json": "66a167a1aa14427403c65bb00d8fdcbca33166c3e0f60e8c6d1688f6f6d69b25", + "science/check.py": "0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e", + "science/history/prior-controls/PROOF.md": "d4113c38bff4c5e2179b445f71db988145c2cee6d8ddea80e9812c0cf659f11c", + "science/history/prior-controls/REPORT.md": "216d40345fda1566db5e338b9018d1f5b29e8586ca9b55468645ca826fe131f6", + "science/history/prior-controls/RESULT.json": "8d376a1662e1a982d744cc3904d3ae6c6881abe820710cfd7aec7166724bffda", + "science/history/prior-controls/SOURCES.json": "952e2054af965e34ebcaf1e37e3fd4bbcffdc6b734fcd9acc68175f5991ede59", + "science/history/prior-controls/check.py": "1cd0967b2149a286f440efe6e7249ff1bdd32b0b8413036e6767dc30bc13d4b7", + "science/history/prior-controls/normal.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "science/history/prior-controls/optimized.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "science/normal.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "science/optimized.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "written-review/FILES.json": "eb1fa1e065e3f316aee9269e097d9451d57eb5977e550b3411f953513833eec8", + "written-review/REVIEW.json": "7c711af68606d73015536a32382ba45507178a23c4af8366dde216b0cff64e79", + "written-review/REVIEW.md": "48600a9ff8f3b7a4e440f93abe5df9661c69c14d134b2624e390d54021bbd5b3" + }, + "schema_version": 1, + "status": "Frozen author science, preserved prior controls, independent operator review and written review; archive prose may name original local paths." +} diff --git a/research/bit-completed-backend-api/PR-DRAFT.md b/research/bit-completed-backend-api/PR-DRAFT.md new file mode 100644 index 0000000000..229ad76ffc --- /dev/null +++ b/research/bit-completed-backend-api/PR-DRAFT.md @@ -0,0 +1,19 @@ +## Change and mathematical scope + +Proves one conditional completed ordinary API implication at4760 A0→4814 A1, under retained P1–P3 native/compiler, older-backend/routing, recurrence/reserve and physical hypotheses. The actual helper462/frame506 witness preserves rank4f, restored ROW, complete spectators and paid routes. This does not independently implement the full primitive API, change actual_backend_API flags, retune a native invoice, complete a caller or improve κ. + +## Task and overlap + +Donor-refined supplier-boundary-audit, canonical Discussion4945. Basecef4b52f2a59009865bf8eabde1be3f159063703; exact ancestral4760ecdfcabd56dfa663ae020733f9f1a88c6644743c and4814f56ae4533a7d97d782a2c596a33fe844cd051747. Adds source-bound interface proof and independent operator/written review beyond4814's existing arithmetic. Historical185/199/204 bootstrap is credited. Neighboring4942threshold/4944CRT-placement obligations are distinct. TASK records the original card and explicit refinement; the package does not audit4088dispatch or4100. + +## Validation + +Run python3 scripts/research_package.py --package research/bit-completed-backend-api. Six registered normal/O author, independent and integrity modes are portable/Git-free directly. Frozen52-file archive includes corrected science, preserved prior weaker controls, independent source/operator packet and separate written review. Author22fixtures/384columns/7controls; independent21988-record/658Boolean-column/436signed-helper/9COPY replay,384operator columns and factor/semantic controls. Source history, committed bytes and official export/Git-free results are recorded in the final head handoff. Full primitive/native/compiler/tape/precision/analytic/outer hypotheses remain unproved. + +## Credit + +ai-nanachi4760/4814/4326; rohanarun185/199 and Maxime Fleury204; Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612 and retained native/E8/ordinary/ROW/stock/weighted-leaf/delayed-cover/precision/tape/outer lineage. Separate author/operator-review/written-review/packaging agents used substantial OpenAI Codex assistance; Apache-2.0. No human or formal-kernel acceptance is claimed. + +## Open next questions + +Supply one literal N-dimensional physical stock/owner/route generator satisfying retained P1–P3, including ROW restoration, finite route/fallback/tape/precision ledger. This is the smallest useful missing primitive-implementation obligation; another root calculation or local fixture does not discharge it. README/TASK retain scope, first step and blockers. diff --git a/research/bit-completed-backend-api/README.md b/research/bit-completed-backend-api/README.md new file mode 100644 index 0000000000..38ea3d923a --- /dev/null +++ b/research/bit-completed-backend-api/README.md @@ -0,0 +1,42 @@ +# Conditional completed ordinary BIT API:4760 A0 to4814 A1 + +This package proves and corroborates one **conditional API implication**: under the explicitly retained P1–P3 native/compiler, older ordinary/routing, recurrence/reserve and physical implementation assumptions, the completed4760 ordinary supplier has the type and paid operations required at the first4814 backend edge. It does not independently implement those primitives, set `actual_backend_API_independently_verified` true, alter a source invoice, complete a multiplication caller or claim a new κ. + +The [all-width proof](science/PROOF.md) treats arbitrary input functions, complete spectators, restored ROW coordinates, distinct physical owners, whole-cover matching, column reversal, weighting and cross-radix padding. The actual witness is helper462 from frame0 to rank4 frame506 inside an8-coordinate native head. Its rank remains4f at column width f. The [author report](science/REPORT.md), [independent source/operator review](independent/REVIEW.md), and [separate written proof review](written-review/REVIEW.md) describe different checked layers and retained assumptions. + +## Sources, scope and overlap + +Canonical base: `cef4b52f2a59009865bf8eabde1be3f159063703`, priority revision7. Sources4760 `ecdfcabd56dfa663ae020733f9f1a88c6644743c` and4814 `f56ae4533a7d97d782a2c596a33fe844cd051747` are ancestors of that base. [ORIGINS.json](ORIGINS.json) records original source paths, Git blobs, hashes and retained portable paths; [SOURCES.json](SOURCES.json) authenticates upstream history. All eight runtime source files are retained exactly under `independent/inputs/`. Five common inputs are byte-identical across4760 and4814. + +This donor-refined `supplier-boundary-audit` task is tracked in [Discussion4945](https://github.com/CrocSwap/integer-mult-bounds/discussions/4945). It addresses a completed interface predicate of [4760](https://github.com/CrocSwap/integer-mult-bounds/pull/4760) and [4814](https://github.com/CrocSwap/integer-mult-bounds/pull/4814), rather than redoing4814's known rational stage gaps or auditing4088 dispatch. Neighboring4942 threshold and4944 CRT-placement work concerns different callees; its layouts and admission are not imported. [TASK.json](TASK.json) preserves the exact original card and declared refinement. + +## Established evidence and price boundary + +The author checks22 fixtures,384 coordinate basis columns and7 boundary controls. Its full prior seven-file freeze is preserved in `science/history/prior-controls/`: two original controls had weaker coverage, which B identified. The corrected wrong-tail control tests a returned physical endpoint; the corrected padding control uses source odd-radix atom reversal. Current proof/report explicitly distinguish the binary pair factor<4 from the full additional fixed-radix conversion. The correction history is preserved rather than relabelled as original coverage. + +B independently reconstructs the actual projector/matcher; replays21988 literal source records on658 Boolean originals and436 signed helper rows with9 COPY episodes; checks384 direct operator columns; and independently classifies and multiplies the proposed elementary factors. Its source/ownership/endpoint/carry controls are separate from A's execution. The written reviewer independently checks noncircularity, nested ROW, padding and the route ledger. These are AI independent reviews, not human or formal verification. + +The selected8-dimensional matcher pair costs80 completed ordinary chunk swaps,80 unit scalings,224 linear ordered shifts, at most128 carry shifts and2 paid finite low-type permutations. A fixed larger compiler N has its own finite counts; the selected constant is not N-uniform. Each weighted unit leaf uses4 old ordinary swaps,3 controlled shifts and1 sign. The ordinary body uses2 raw completed bodies and3 additions; ROW/radix padding, high-part exchange, owned copies, precision, tapes and full bad-class fallback remain charged. See [BUDGET.md](BUDGET.md). + +## Reproduce + +From the repository root, using Python3.12 and only its standard library: + +```sh +python3 -I -W error -B research/bit-completed-backend-api/verify.py author +python3 -I -W error -B research/bit-completed-backend-api/verify.py independent +python3 -I -W error -B research/bit-completed-backend-api/verify.py controls +python3 scripts/research_package.py --package research/bit-completed-backend-api +``` + +`VERIFY.json` registers each mode in ordinary and optimized Python. Direct modes also work in an official package export with Git absent from PATH; generic metadata/history checks require the repository. The author wrapper changes only its single `git show` byte-reader in memory, preserves the unchanged checker file/hash and assertions, and regenerates RESULT/SOURCES only in private scratch. B's checker is already Git-free and reads its retained inputs. Frozen science is never overwritten. [PACKET.json](PACKET.json) authenticates52 frozen files, including both reviews and history; [VALIDATION.md](VALIDATION.md) explains the evidence and limits. + +Frozen review/proposal prose names the original local output paths and publication status. Those are archived provenance. Published reproduction uses the package paths above; `proposal/` is the pre-execution proposal and does not supersede this README or authorize a new run. No full658/11400 physical native compiler, astronomical uniform template, large-q generator, Lean, Docker or complete selected cold replay is claimed. + +## Open next questions + +The next useful obligation is a literal source-bound N-dimensional physical stock/role/route generator satisfying P1–P3. Begin with one fixed invocation and its complete owner, restored ROW, paid route/fallback, tape/precision and finite-constant ledger. Until that primitive implementation and analytic/outer recovery are supplied, this conditional closure cannot promote full actual-backend API admission. Structured relevance, first step and blockers are in [TASK.json](TASK.json). + +## Credit + +Credit ai-nanachi4760/4814 and compact436/4326; rohanarun185/199 and Maxime Fleury204 for prior finite acyclic bootstrap/ROW composition; Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612; and all retained native, E8, ordinary, weighted-leaf, delayed-cover, stock, precision, tape and outer contributors. Prepared for Chris R / Clear1nsight with substantial OpenAI Codex assistance. Author, independent source/operator review, written proof review and portable packaging used separate assigned agents. Apache-2.0; source bytes, attribution and license retained. No human or proof-kernel review is claimed. diff --git a/research/bit-completed-backend-api/SOURCES.json b/research/bit-completed-backend-api/SOURCES.json new file mode 100644 index 0000000000..65a428051d --- /dev/null +++ b/research/bit-completed-backend-api/SOURCES.json @@ -0,0 +1,81 @@ +{ + "schema_version": 1, + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "notes/three-stage-cover-bit.tex", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:notes/three-stage-cover-bit.tex", + "git_blob": "f05225d21f92cf8cef21b6e12601d5b4d61991f0", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "path": "notes/three-stage-cover-rows.tex", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:notes/three-stage-cover-rows.tex", + "git_blob": "590da4b892a08b9d5182fb3d8a983c6239dd27db", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8" + }, + { + "path": "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz", + "git_blob": "776ddd13d67b2259e90d39de5b42e4df4b1447f1", + "sha256": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b" + }, + { + "path": "research/bit-finite-ordinary-bootstrap/PROOF.md", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:research/bit-finite-ordinary-bootstrap/PROOF.md", + "git_blob": "7db6805f8a9ae77b28c5772ee6de3e47777912b1", + "sha256": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2" + }, + { + "path": "research/bit-finite-ordinary-bootstrap/RECORD.json", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:research/bit-finite-ordinary-bootstrap/RECORD.json", + "git_blob": "3c8934f23e3d58d8ad5bcfb0abd58b44810a994d", + "sha256": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8" + }, + { + "path": "research/bit-finite-ordinary-bootstrap/independent.py", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:research/bit-finite-ordinary-bootstrap/independent.py", + "git_blob": "498ebb37a3408fc0292e183a6e11490109b604d2", + "sha256": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38" + }, + { + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "git_blob": "a58774e237c9362869a60a22bda35be09fb85872", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "usage": "provenance", + "pin": "head:f56ae4533a7d97d782a2c596a33fe844cd051747:research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "git_blob": "a9a932b9268da28af9ba4bccdab205c5bcd50ad3", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + { + "path": "research/bit-compact-carrier-retirement/PROOF.md", + "usage": "provenance", + "pin": "head:ecdfcabd56dfa663ae020733f9f1a88c6644743c:research/bit-compact-carrier-retirement/PROOF.md", + "git_blob": "ad62aadb5bd9c4f1b8febcba62125240878e7f2d", + "sha256": "6b960ae2449e21b566cd5bb1bb767df46615984f3afd35d510743b1d3a6dc385" + } + ] +} diff --git a/research/bit-completed-backend-api/TASK.json b/research/bit-completed-backend-api/TASK.json new file mode 100644 index 0000000000..d7f373541a --- /dev/null +++ b/research/bit-completed-backend-api/TASK.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Conditional completed ordinary API implication at the FIRST PR4760 A0 to PR4814 A1 edge, with actual helper462/frame506, all-width written P1-P3 proof, exact portable finite source/operator fixtures and separate independent mathematical review. Full primitive/native/compiler/tape implementation and actual_backend_API admission remain unproved; no new kappa.", + "scope_change_reason": "Explicit donor Discussion4945 assignment narrows the historical supplier-boundary-audit card to one current completed-backend admission predicate. This does not audit4088 dispatch or4100, retune ordinary decimals, or resolve retained physical/compiler premises.", + "bottleneck_link": "Independent API compatibility is separate from a scalar exponent check. This packet proves conditional type/cost closure without promoting the full primitive API or the global frontier.", + "budget_minutes": 60, + "stop_rule": "Stop after the fixed first backend edge, corrected finite controls, independent source/operator and written reviews, immutable source authentication and portable publication checks. No all-size physical compiler implementation, new backend level, family construction or kappa claim.", + "outcome": "partial", + "evidence": "Frozen corrected author proof/checker/22 fixtures/384 coordinate columns/7 controls; independent source replay of21988records,658 Boolean originals,436 signed helper rows and9 COPY episodes; independent384 basis-column/operator/factor/ownership controls; separate all-width written review. Original weak controls retained as history. Registered portable normal/O replay authenticates all frozen bytes and privately regenerates author receipts.", + "author": "Prepared for Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex assistance. Separately assigned gpt-6.1-sol/high agents wrote author proof/checker, independently audited source/operator/control behavior, reviewed written P1-P3/ROW/padding/ledger proof, and packaged immutable portable replay. No human or proof-kernel verification.", + "open_questions": [ + { + "question": "Can a literal all-width N-dimensional physical stock/role/route generator discharge the retained P1-P3 primitive implementation hypotheses for this fixed source?", + "why_it_matters": "The conditional compatibility proof does not establish actual native/compiler ROW restoration, distinct physical allocation, tape/precision costs or complete ordinary/outer admission.", + "first_step": "Choose one fixed completed source invocation, emit its physical owners, restored ROW, paid matcher/fallback routes and compiler constants, and test the claimed primitive implementation against arbitrary spectator inputs.", + "blocked_by": "No literal full primitive/compiler/tape implementation or analytic/outer recovery is supplied by the finite fixtures or written implication." + } + ] +} diff --git a/research/bit-completed-backend-api/VALIDATION.md b/research/bit-completed-backend-api/VALIDATION.md new file mode 100644 index 0000000000..69a240a70c --- /dev/null +++ b/research/bit-completed-backend-api/VALIDATION.md @@ -0,0 +1,9 @@ +# Verification layers and remaining obligations + +The six registered commands run author, independent and integrity-control modes in normal and optimized Python. Author mode authenticates all frozen evidence, reruns22fixtures/384columns/7corrected controls and privately regenerates exact RESULT/SOURCES. Independent mode executes unchanged Bcode without importing Achecker or predecessor engines, derives source flow/operator/factor/control evidence, and compares its full JSON with the frozen independent result. Integrity mode corrupts private copies of source/frame bytes, a result and the checker and requires rejection. Semantic mutations remain in both substantive checkers; hash controls are not represented as mathematical counterexamples. + +The separate written review proves no new primitive: it accepts the conditional P1–P3 implication, nested ROW restoration, whole-cover matching, source-typed padding and paid route ledger. P1 includes actual all-width raw/native/compiler semantics. P2 includes older completed ordinary and physical rational-routing primitives. P3 includes source recurrence/reserve and new fixed compiler constants. Their implementation truth, precision/tapes, analytic/prime/outer recovery and a literal astronomical compiled generator remain open. The full actual-backend API flag remains false. + +All8 runtime upstream files are retained byteexact with original Git/blob/SHA provenance. PACKET authenticates all52 frozen science/history/proposal/review files. CRLF source bytes are preserved by package-local -text attributes. The portable wrapper rebinds only one source-read call in memory; the original frozen checker bytes and __file__ hash remain exact. No remote or fork-only runtime dependency exists; both4760/4814heads are ancestors of canonical basecef4. + +Run registered metadata/source-history/committed-byte checks after committing, then official export/check and all six direct modes in a Git-free extracted bundle. Those packaging checks establish source availability and transport/replay integrity, not mathematical admission. Final exact head, export hash and measured commands belong in the local packaging receipt/public handoff. Do not interpret archived proposal/review local paths as published repro paths. diff --git a/research/bit-completed-backend-api/VERIFY.json b/research/bit-completed-backend-api/VERIFY.json new file mode 100644 index 0000000000..e6514a93f6 --- /dev/null +++ b/research/bit-completed-backend-api/VERIFY.json @@ -0,0 +1,90 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py", + "author" + ], + "timeout_seconds": 90, + "checks": "Authenticate frozen science/source bytes, retain original checker hash and assertions, rebind only Git byte-reader in memory,22 fixtures/384 columns/7 corrected semantic controls, private-scratch RESULT/SOURCES regeneration. Conditional API only; primitive/compiler/tape remain assumptions." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py", + "author" + ], + "timeout_seconds": 90, + "checks": "Authenticate frozen science/source bytes, retain original checker hash and assertions, rebind only Git byte-reader in memory,22 fixtures/384 columns/7 corrected semantic controls, private-scratch RESULT/SOURCES regeneration. Conditional API only; primitive/compiler/tape remain assumptions." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py", + "independent" + ], + "timeout_seconds": 90, + "checks": "Unchanged independent Git-free source/operator checker:21988 source records,658 Boolean original columns,436 signed helpers,9 charged COPY episodes,384 direct coordinate columns,5swap/5scale/14shear factor witness and endpoint/ownership/source/carry controls. Does not prove generic physical compiler/ROW." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py", + "independent" + ], + "timeout_seconds": 90, + "checks": "Unchanged independent Git-free source/operator checker:21988 source records,658 Boolean original columns,436 signed helpers,9 charged COPY episodes,384 direct coordinate columns,5swap/5scale/14shear factor witness and endpoint/ownership/source/carry controls. Does not prove generic physical compiler/ROW." + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py", + "controls" + ], + "timeout_seconds": 90, + "checks": "Private-copy source/frame, frozen result and checker corruption must fail exact authentication. These are integrity controls; semantic mutations run in both science modes." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py", + "controls" + ], + "timeout_seconds": 90, + "checks": "Private-copy source/frame, frozen result and checker corruption must fail exact authentication. These are integrity controls; semantic mutations run in both science modes." + } + ] +} diff --git a/research/bit-completed-backend-api/independent/CONTROL-CORRECTION.diff b/research/bit-completed-backend-api/independent/CONTROL-CORRECTION.diff new file mode 100644 index 0000000000..fc5887a3cd --- /dev/null +++ b/research/bit-completed-backend-api/independent/CONTROL-CORRECTION.diff @@ -0,0 +1,50 @@ +--- initial/check.py ++++ corrected/check.py +@@ -84,8 +84,15 @@ + # This wrong C8 tensor I_f must fail at f2, unless accidentally symmetric. + if f==2: + wrong=[[F(i//f+j//f==7 and i%f==j%f)for j in range(n)]for i in range(n)] +- need(wrong!=[[F(i+j==n-1)for j in range(n)]for i in range(n)],'wrong tail reversal distinguished') +- controls['omit_column_tail_reversal']=True ++ # Mutate the actual canonical child's tail pairing, then use the ++ # correct source routes; compare the returned physical endpoint. ++ u=add(eye(n),Qf,-1) ++ wrong_child=[x+y for x,y in zip(u,mm(Qf,wrong))]+[x+y for x,y in zip(mm(wrong,Qf),add(eye(n),mm(mm(wrong,Qf),wrong),-1))] ++ wrong_endpoint=mm(mm(paired_map(Sf),wrong_child),paired_map(Sfi)) ++ actual_endpoint=paired(Pf) ++ mismatch=next((i,j)for i in range(2*n)for j in range(2*n)if wrong_endpoint[i][j]!=actual_endpoint[i][j]) ++ need(wrong_endpoint!=actual_endpoint,'wrong tail actual returned physical operator fails') ++ controls['omit_column_tail_reversal']={'basis_column':mismatch[1],'output_coordinate':mismatch[0],'wrong':str(wrong_endpoint[mismatch[0]][mismatch[1]]),'actual':str(actual_endpoint[mismatch[0]][mismatch[1]])} + for prime in (5,7): + m=prime**2 + for variant in (0,1): +@@ -182,16 +189,22 @@ + genuinely=set((i,j)for i in range(original)for j in range(original));returned={(j,i)for i,j in genuinely} + need(returned==genuinely,'completed ordinary swap preserves genuine rectangle') + need(all((i=row_stock and row_padded<2*source,'owned ROW pad bound') +- bits=padded.bit_length()-1 +- rev=lambda n:sum(((n>>i)&1)<<(bits-1-i)for i in range(bits)) ++ # Source F_n reverses ODD-RADIX atom positions, not binary bits. ++ # Keep caller radix5/7 and use the other declared prime internally. ++ inner=7 if radix==5 else 5;inner_width=2 if radix==5 else 3;inner_range=inner**inner_width ++ def rev(n): ++ out=0 ++ for _ in range(inner_width):out=out*inner+n%inner;n//=inner ++ return out + bad={(rev(j),rev(i))for i,j in genuinely} +- need(bad!=genuinely,'actual raw reversed body violates genuine padding rectangle') +- controls['premature_padding_cleanup']=True +- padding.append({'radix':radix,'digit_width':2,'range':original,'binary_range':padded,'two_range_volume_factor':str(F(padded**2,original**2)),'row_divisor':row_stock,'padded_row_range':row_padded,'owned_padded_rows':row_padded-source}) ++ need(bad!=genuinely,'source odd-radix raw reversed body violates genuine rectangle') ++ witness=next((i,j)for i in range(original)for j in range(original)if rev(j)>=original or rev(i)>=original) ++ controls.setdefault('premature_padding_cleanup',[]).append({'caller_radix':radix,'genuine_range':original,'inner_radix':inner,'inner_width':inner_width,'padded_inner_range':inner_range,'input':list(witness),'raw_output':[rev(witness[1]),rev(witness[0])]}) ++ padding.append({'radix':radix,'digit_width':2,'range':original,'binary_range':padded,'two_range_volume_factor':str(F(padded**2,original**2)),'inner_radix':inner,'inner_width':inner_width,'inner_padded_range':inner_range,'full_cross_radix_volume_factor':str(F(inner_range**2,original**2)),'row_divisor':row_stock,'padded_row_range':row_padded,'owned_padded_rows':row_padded-source}) + # Reject omitted physical whole-job matcher with actual matrices. + controls['omit_matcher']=paired(Q)!=paired(P) + need(all(controls.values()),'every semantic control distinguishes') diff --git a/research/bit-completed-backend-api/independent/CORRECTED-HASHES.json b/research/bit-completed-backend-api/independent/CORRECTED-HASHES.json new file mode 100644 index 0000000000..4f3a9f585b --- /dev/null +++ b/research/bit-completed-backend-api/independent/CORRECTED-HASHES.json @@ -0,0 +1,9 @@ +{ + "check.py": "0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e", + "RESULT.json": "965b650c0e49572e028f89a60943c64ad8dff9032fc93272b86cd1f9715a77b7", + "SOURCES.json": "66a167a1aa14427403c65bb00d8fdcbca33166c3e0f60e8c6d1688f6f6d69b25", + "PROOF.md": "61d40f649f0afc6116c05dbe370323dd5f38849214d37eb983a4101410818b0b", + "REPORT.md": "45971605fa01dd3fd1b54f8fb22809f7e5c635995d0640bafc0be29e567fb9f7", + "normal.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "optimized.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18" +} diff --git a/research/bit-completed-backend-api/independent/FILES.json b/research/bit-completed-backend-api/independent/FILES.json new file mode 100644 index 0000000000..ce30438a4b --- /dev/null +++ b/research/bit-completed-backend-api/independent/FILES.json @@ -0,0 +1,35 @@ +{ + "scope": "Independent4945source/operator/type/controlreviewonly; conditionalimplementationpremisesremaininherited", + "files": { + "CONTROL-CORRECTION.diff": "9503b93115e59028f56e632b02fdd0263c80af925177aa117f73056e21531c2b", + "CORRECTED-HASHES.json": "e6900604c89d331731f3fcb4f01c1c36c16d67f5ae08404e370ddd9b119b3d1c", + "FROZEN-HASHES.json": "65ab2038c80471498087124fedb196346cdf3975101c86feafc30d4de6cc6241", + "INDEPENDENT.json": "7818430484073c50aa50e4ded758d2acc0faf556c9f98ae7c91420269260fdab", + "REVIEW.md": "43c9d67d6eb6965ab304b42af4e07fccdba9843ee00995656014bee53746579a", + "RUNS.json": "3b126e460ac1e9af21f36ccd43cef90a80d883139503f4e287175faf84ec99d3", + "SOURCE-BINDING.json": "7f99637e46607dbcfa950767b17607bf8acc50d7379b02d6a95ef3cbb5bc4d7b", + "corrected/PROOF.md": "61d40f649f0afc6116c05dbe370323dd5f38849214d37eb983a4101410818b0b", + "corrected/REPORT.md": "45971605fa01dd3fd1b54f8fb22809f7e5c635995d0640bafc0be29e567fb9f7", + "corrected/RESULT.json": "965b650c0e49572e028f89a60943c64ad8dff9032fc93272b86cd1f9715a77b7", + "corrected/SOURCES.json": "66a167a1aa14427403c65bb00d8fdcbca33166c3e0f60e8c6d1688f6f6d69b25", + "corrected/check.py": "0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e", + "corrected/normal.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "corrected/optimized.log": "35429d4210387ba62b14062202adfde6dcaa0671613fc262a83003fec5cf7f18", + "frozen/PROOF.md": "d4113c38bff4c5e2179b445f71db988145c2cee6d8ddea80e9812c0cf659f11c", + "frozen/REPORT.md": "216d40345fda1566db5e338b9018d1f5b29e8586ca9b55468645ca826fe131f6", + "frozen/RESULT.json": "8d376a1662e1a982d744cc3904d3ae6c6881abe820710cfd7aec7166724bffda", + "frozen/SOURCES.json": "952e2054af965e34ebcaf1e37e3fd4bbcffdc6b734fcd9acc68175f5991ede59", + "frozen/check.py": "1cd0967b2149a286f440efe6e7249ff1bdd32b0b8413036e6767dc30bc13d4b7", + "independent-normal.log": "7818430484073c50aa50e4ded758d2acc0faf556c9f98ae7c91420269260fdab", + "independent-optimized.log": "7818430484073c50aa50e4ded758d2acc0faf556c9f98ae7c91420269260fdab", + "independent.py": "4bd2d0551886e288b8802070b85c09ea81632fe9196227cde9ae87b9f797dce3", + "inputs/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "inputs/PROOF.md": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "inputs/RECORD.json": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "inputs/WORD.json.gz": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "inputs/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010", + "inputs/independent.py": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "inputs/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "inputs/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8" + } +} diff --git a/research/bit-completed-backend-api/independent/FROZEN-HASHES.json b/research/bit-completed-backend-api/independent/FROZEN-HASHES.json new file mode 100644 index 0000000000..25a0ca05c0 --- /dev/null +++ b/research/bit-completed-backend-api/independent/FROZEN-HASHES.json @@ -0,0 +1,7 @@ +{ + "check.py": "1cd0967b2149a286f440efe6e7249ff1bdd32b0b8413036e6767dc30bc13d4b7", + "RESULT.json": "8d376a1662e1a982d744cc3904d3ae6c6881abe820710cfd7aec7166724bffda", + "PROOF.md": "d4113c38bff4c5e2179b445f71db988145c2cee6d8ddea80e9812c0cf659f11c", + "REPORT.md": "216d40345fda1566db5e338b9018d1f5b29e8586ca9b55468645ca826fe131f6", + "SOURCES.json": "952e2054af965e34ebcaf1e37e3fd4bbcffdc6b734fcd9acc68175f5991ede59" +} diff --git a/research/bit-completed-backend-api/independent/INDEPENDENT.json b/research/bit-completed-backend-api/independent/INDEPENDENT.json new file mode 100644 index 0000000000..3bbe2ee4e2 --- /dev/null +++ b/research/bit-completed-backend-api/independent/INDEPENDENT.json @@ -0,0 +1,520 @@ +{ + "status": "PASS_INDEPENDENT4945_SOURCE_OPERATOR_FIXTURE_REVIEW", + "source_heads": [ + "ecdfcabd56dfa663ae020733f9f1a88c6644743c", + "f56ae4533a7d97d782a2c596a33fe844cd051747" + ], + "source_binding": { + "helper": 462, + "start": 0, + "finish": 506, + "rank": 4, + "five_common4760_4814_inputs_equal": true + }, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "source_flow": { + "original_columns": 658, + "independent_integer_helpers": 436, + "helper462_signedrow": { + "462": 1 + }, + "owned_COPY_lifetimes": 9, + "paid": { + "1": 1319, + "2": 1342, + "3": 78, + "4": 39, + "5": 102, + "7": 18, + "6": 10 + } + }, + "actual_right_factor_counts": { + "swap": 5, + "scale": 5, + "add": 14 + }, + "actual_scaling_units": [ + "2", + "2", + "-1", + "-2", + "2" + ], + "selected_pair_ledger_corollary": { + "ordinary": 80, + "scalings": 80, + "linear_shifts": 224, + "carry_shifts_upper": 128, + "low_type_permutations": 2 + }, + "source_operator_fixtures": [ + { + "f": 1, + "prime": 5, + "cover_variant": 0, + "ancestor": 0, + "columns": 16 + }, + { + "f": 1, + "prime": 5, + "cover_variant": 0, + "ancestor": 1, + "columns": 16 + }, + { + "f": 1, + "prime": 5, + "cover_variant": 1, + "ancestor": 0, + "columns": 16 + }, + { + "f": 1, + "prime": 5, + "cover_variant": 1, + "ancestor": 1, + "columns": 16 + }, + { + "f": 1, + "prime": 7, + "cover_variant": 0, + "ancestor": 0, + "columns": 16 + }, + { + "f": 1, + "prime": 7, + "cover_variant": 0, + "ancestor": 1, + "columns": 16 + }, + { + "f": 1, + "prime": 7, + "cover_variant": 1, + "ancestor": 0, + "columns": 16 + }, + { + "f": 1, + "prime": 7, + "cover_variant": 1, + "ancestor": 1, + "columns": 16 + }, + { + "f": 2, + "prime": 5, + "cover_variant": 0, + "ancestor": 0, + "columns": 32 + }, + { + "f": 2, + "prime": 5, + "cover_variant": 0, + "ancestor": 1, + "columns": 32 + }, + { + "f": 2, + "prime": 5, + "cover_variant": 1, + "ancestor": 0, + "columns": 32 + }, + { + "f": 2, + "prime": 5, + "cover_variant": 1, + "ancestor": 1, + "columns": 32 + }, + { + "f": 2, + "prime": 7, + "cover_variant": 0, + "ancestor": 0, + "columns": 32 + }, + { + "f": 2, + "prime": 7, + "cover_variant": 0, + "ancestor": 1, + "columns": 32 + }, + { + "f": 2, + "prime": 7, + "cover_variant": 1, + "ancestor": 0, + "columns": 32 + }, + { + "f": 2, + "prime": 7, + "cover_variant": 1, + "ancestor": 1, + "columns": 32 + } + ], + "weighted_leaf_fixtures": [ + { + "prime": 5, + "unit": 2, + "ordinary_calls": 4 + }, + { + "prime": 5, + "unit": 3, + "ordinary_calls": 4 + }, + { + "prime": 7, + "unit": 2, + "ordinary_calls": 4 + }, + { + "prime": 7, + "unit": 3, + "ordinary_calls": 4 + } + ], + "padding_fixtures": [ + { + "genuine": 25, + "binary_pad": 32, + "inner_prime": 7, + "inner_digits": 2, + "inner_complete_range": 49, + "raw_source_coordinate": 4, + "raw_reversed_coordinate": 28, + "paired_binary_factor": "1024/625" + }, + { + "genuine": 49, + "binary_pad": 64, + "inner_prime": 5, + "inner_digits": 3, + "inner_complete_range": 125, + "raw_source_coordinate": 2, + "raw_reversed_coordinate": 50, + "paired_binary_factor": "4096/2401" + } + ], + "fixtures_total": 22, + "actual_basis_columns": 384, + "independent_controls": { + "wrong_column_tail_endpoint": { + "f": 2, + "prime": 5, + "cover_variant": 0, + "ancestor": 0, + "basis_column": 2, + "first_different_coordinate": 26 + }, + "drop_actual_high_carry": [ + { + "prime": 5, + "nonzero_carry": [ + 0, + 5, + 4 + ] + }, + { + "prime": 7, + "nonzero_carry": [ + 0, + 5, + 6 + ] + } + ], + "fresh_ROW_weight": { + "input_weight": 1, + "routed_weight": 2, + "nonzero_head_coordinate": 1 + }, + "omit_matcher": 0, + "premature_unpad_source_typed_radix": [ + { + "genuine": 25, + "binary_pad": 32, + "inner_prime": 7, + "inner_digits": 2, + "inner_complete_range": 49, + "raw_source_coordinate": 4, + "raw_reversed_coordinate": 28, + "paired_binary_factor": "1024/625" + }, + { + "genuine": 49, + "binary_pad": 64, + "inner_prime": 5, + "inner_digits": 3, + "inner_complete_range": 125, + "raw_source_coordinate": 2, + "raw_reversed_coordinate": 50, + "paired_binary_factor": "4096/2401" + } + ], + "borrowed_receiver_for_ownedCOPY": true, + "fake_rank8_credit": true, + "wrong_actual_exitframe": true, + "conflated_two_ROW_slots": true, + "sourcebyte_mutation": true + }, + "allwidth_scope": "Rationaloperatoridentity/sourcepremises; fixturescorroborate. NativeROW/tape/compilerremaininherited; nofullbackendAPIclaim.", + "A_checker_or_result_imported": false, + "new_kappa": null +} diff --git a/research/bit-completed-backend-api/independent/REVIEW.md b/research/bit-completed-backend-api/independent/REVIEW.md new file mode 100644 index 0000000000..fbc7b2f2d1 --- /dev/null +++ b/research/bit-completed-backend-api/independent/REVIEW.md @@ -0,0 +1,162 @@ +# Independent source/operator review of the bounded4945 BIT API gate + +**PASS for the reviewed source bindings, finite operator/type fixtures and +corrected semantic controls.** No unresolved implementation finding remains +within that bounded scope. Written P1–P3/noncircularity and ledger logic were +reviewed separately by D; this report does not duplicate that proof review. +Neither review independently establishes the primitive ROW/tape/native-compiler +implementation or promotes 4814's complete actual-backend-API flag. + +## Exact reviewed freeze and source chain + +Final corrected A packet, under +`dyadic-full-controller-20261023/outputs/bit-completed-backend-api-gate/implementation/`: + +- check.py: `0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e` +- RESULT.json: `965b650c0e49572e028f89a60943c64ad8dff9032fc93272b86cd1f9715a77b7` +- SOURCES.json: `66a167a1aa14427403c65bb00d8fdcbca33166c3e0f60e8c6d1688f6f6d69b25` +- PROOF.md: `61d40f649f0afc6116c05dbe370323dd5f38849214d37eb983a4101410818b0b` +- REPORT.md: `45971605fa01dd3fd1b54f8fb22809f7e5c635995d0640bafc0be29e567fb9f7` + +The initial packet is preserved separately under frozen/. The corrected copy +is under corrected/. CORRECTED-HASHES.json fixes every copied byte, and +CONTROL-CORRECTION.diff preserves the bounded change. This reviewer did not +edit A's source/implementation files. The previous seven-file snapshot remains +archived by A as well. + +All 8 declared source SHA256 values were compared against exact raw Git blobs +at 4814 `f56ae4533a7d97d782a2c596a33fe844cd051747`. The frame bank, provider +WORD, BIT notes, ROW notes and delayed-cover bridge are byte-identical at 4760 +`ecdfcabd56dfa663ae020733f9f1a88c6644743c`. Bootstrap PROOF/RECORD/independent +files are introduced at 4814. SOURCE-BINDING.json records this distinction; +no fork-only replacement, reconstructed source or ambient module was used. + +## Independent concrete helper and literal-source checks + +The immutable WORD has 658 original fields. Helper 462 is an arbitrary cold +original at frame 0 and finishes at actual frame 506, dimension 4. From that +frame's exact B image rows and A kernel rows, this reviewer independently +computes + + P=B^T(BB^T)^-1 B, S=[B^T|A^T], Q=diag(I4,0). + +The checks verify rank(B)=rank(A)=4, BA^T=0, S invertible, P²=P, +rank(P)=4 and SQS^-1=P. Neither A's matcher executable nor its asserted +projector/matcher receipt is imported as proof. The reconstructed matrices +are recorded in INDEPENDENT.json. + +A separate, inexpensive literal interpreter replays all 21,988 original local +records. It checks all 658 Boolean input columns, exact integer own-input +rows for every 436 helper, all actual endpoint frames, every rational nested +MOVE and common-frame signed ADD, and all 9 charged owned-COPY lifetimes. +The temporary is private index 658; no arbitrary field is erased or reused +as an owned receiver. Helper 462's signed row is exactly its own original. +The complete paid profile recounts + + {1:1319,2:1342,3:78,4:39,5:102,6:10,7:18}. + +This is source requalification, not a fresh all-size compiler or physical +ROW implementation. Its VALUE-flow and actual-frame checks support the +particular finite helper binding under the retained native job semantics. +No full 11400-owner caller or astronomical compiler was executed. + +## Independent 384-column operator audit and 22-fixture coverage + +A's frozen corrected checker reproduces 22 fixtures, 384 physical-coordinate +basis columns and 7 controls in both normal and optimized Python. This reviewer +also implements the coordinate actions separately, without importing A's +check functions, predecessor helper_matchers, pricing engine or factorizer. + +For f=1,2; prime5,7 modulo prime²; two fixed cover representatives g; and +two ancestor weights, the independent interpreter applies the route through +gS and the canonical rank-4 projector, including reversal of BOTH row and +column order. It compares every returned basis column against a direct +projector action on the head/tail coordinates. All 384 agree. These are 16 +source/operator fixtures; 4 literal weighted-leaf fixtures and 2 padding-type +fixtures complete the same 22-case footprint. They are not a random search, +GL census or an empirical universal proof. + +The four weighted-leaf cases check the actual point action of four old +ordinary swaps, three shifts and one sign on both two-dimensional basis +inputs. The two padding cases separately record the positive binary paired +volume factors 1024/625 and 4096/2401. The ordinary completed endpoint's +genuine-rectangle invariance is the written source premise/argument; these +small fixtures do not establish the real q>2^45 N^5 compiler or a threshold. + +The proposed elementary-factor matrices in the corrected receipt are treated +as a candidate witness, not accepted by declaration. This reviewer classifies +every matrix, checks every scaling is a unit at the fixture primes, and +multiplies the full chronological right product back to the actual source S. +It has 5 swaps, 5 scalings and 14 shears. Thus the selected 8-row pair ledger is +80 completed ordinary interchanges, 80 fixed unit scalings, 224 linear shifts, +at most 128 carry shifts and 2 separately charged low-type permutations. +This is the selected coarse matcher, not a final compiled program count. +The fixed larger compiler N and its routing implementation remain inherited. + +Independent actual high-matrix calculations include a nonzero high entry and +nonzero q-adic carry; dropping the carry changes the route. A fresh-ROW-reading +weight also gives a nonzero route/weight commutator. The legal ancestor-only +weight remains independent of the current fresh row. The fixture's declared +two ROW slots are distinct physical types; a conflated-slot mutation rejects. +This does not execute or prove the actual primitive ROW restoration machine. + +## Findings corrected before acceptance + +Two finite-control coverage weaknesses were identified in the initial snapshot: + +1. Its missing-column-tail flag only checked that two reversal matrices differ. + It did not compare a wrongly routed endpoint with the requested operator. + The corrected packet now records an actual operator mismatch: basis 26, + output 2 gives wrong 1/2 versus correct 0. Independently, the modular weighted + coordinate audit finds a wrong-tail mismatch at basis2/output 26. +2. Its premature-unpadding negative called binary bit reversal an actual raw + body, although the declared source F_n reverses odd-radix atom positions. + The corrected controls use source-typed raw-contract instances: genuine + range 25 embedded in base7²=49, where (0,4) maps to(28,0), and genuine + range 49 embedded in base5³=125, where (0,2) maps to(50,0). The finite + full cross-radix factors 2401/625 and 15625/2401 are separate from the + below-four binary padding factors. These do not assert that actual A0 + uses those raw bodies at those tiny widths; its small-width fallback + remains explicitly inherited. + +Both changes strengthen finite negative controls without changing the matcher, +positive operator fixtures, all-width proof, productive invoice or P1–P3. +The original evidence and correction diff remain visible. No theorem-level +counterexample was found. + +Additional independent controls reject a borrowed field substituted for the +private COPY receiver, fake rank-8 credit for the actual rank-4 helper, a wrong +actual helper exit frame, conflated ROW physical slots and a source-byte +corruption. These are type/ownership/source controls, not synthetic changes +to exponent arithmetic or an independent proof of the primitive API. + +## Replay and limits + +From the worktree root: + +```sh +python3 -I -W error -B outputs/bit-api-independent-review/corrected/check.py +python3 -I -O -W error -B outputs/bit-api-independent-review/corrected/check.py +python3 -I -W error -B outputs/bit-api-independent-review/independent.py +python3 -I -O -W error -B outputs/bit-api-independent-review/independent.py +``` + +The corrected author checker reads exact Git objects and compares frozen bytes; +no --write was used. The independent script reads authenticated local source +snapshots only and can run with Git absent from PATH. It validates the proposed +factor witness rather than treating A's RESULT as a proof. Normal/optimized +scientific outputs agree. RUNS.json records final execution evidence. + +The actual all-width native/compiler ROW contract, ordered-affine/scaling/tape +implementation, generated precision and machine constants, analytic/prime/outer +recovery remain inherited P1–P3. Neither fixture nor literal local replay proves +the whole completed backend implementation. No new native invoice, source field, +selected record, full actual-backend flag or global κ is changed by this review. +D's separate written proof review determines the quantified conditional +composition claim; this report supplies its disjoint source/operator evidence. + +Credit ai-nanachi4760/4814/4326; rohanarun185/199 and Maxime Fleury204; +Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612 +and retained native, ordinary, ROW, routing, stock, precision and tape authors. +Prepared for Chris R/Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0; no independent human or formal proof-kernel acceptance is claimed. diff --git a/research/bit-completed-backend-api/independent/RUNS.json b/research/bit-completed-backend-api/independent/RUNS.json new file mode 100644 index 0000000000..b5acd7c9e7 --- /dev/null +++ b/research/bit-completed-backend-api/independent/RUNS.json @@ -0,0 +1,42 @@ +{ + "status": "PASS_CORRECTED_AUTHOR_AND_INDEPENDENT_NORMAL_OPTIMIZED", + "runs": [ + { + "checker": "independent.py", + "optimized": false, + "PATH": "/nonexistent", + "seconds": 0.351, + "frozen_result_equal": true + }, + { + "checker": "independent.py", + "optimized": true, + "PATH": "/nonexistent", + "seconds": 0.48, + "frozen_result_equal": true + }, + { + "checker": "corrected/check.py", + "optimized": false, + "seconds": 0.976, + "coverage": [ + 22, + 384, + 7 + ], + "default_read_only": true + }, + { + "checker": "corrected/check.py", + "optimized": true, + "seconds": 1.154, + "coverage": [ + 22, + 384, + 7 + ], + "default_read_only": true + } + ], + "primitive_ROW_tape_nativecompiler_proved": false +} diff --git a/research/bit-completed-backend-api/independent/SOURCE-BINDING.json b/research/bit-completed-backend-api/independent/SOURCE-BINDING.json new file mode 100644 index 0000000000..54ad95f705 --- /dev/null +++ b/research/bit-completed-backend-api/independent/SOURCE-BINDING.json @@ -0,0 +1,61 @@ +{ + "sources": [ + { + "local": "inputs/three-stage-cover-bit.tex", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "notes/three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "4760_same_bytes": true + }, + { + "local": "inputs/three-stage-cover-rows.tex", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "notes/three-stage-cover-rows.tex", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "4760_same_bytes": true + }, + { + "local": "inputs/WORD.json.gz", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz", + "sha256": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "4760_same_bytes": true + }, + { + "local": "inputs/PROOF.md", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-finite-ordinary-bootstrap/PROOF.md", + "sha256": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "4760_same_bytes": false + }, + { + "local": "inputs/RECORD.json", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-finite-ordinary-bootstrap/RECORD.json", + "sha256": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "4760_same_bytes": false + }, + { + "local": "inputs/independent.py", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-finite-ordinary-bootstrap/independent.py", + "sha256": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "4760_same_bytes": false + }, + { + "local": "inputs/DELAYED-COVER-BRIDGE.md", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "4760_same_bytes": true + }, + { + "local": "inputs/frames.json", + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010", + "4760_same_bytes": true + } + ], + "checker_sha256_matches": true +} diff --git a/research/bit-completed-backend-api/independent/corrected/PROOF.md b/research/bit-completed-backend-api/independent/corrected/PROOF.md new file mode 100644 index 0000000000..a2db2c2bab --- /dev/null +++ b/research/bit-completed-backend-api/independent/corrected/PROOF.md @@ -0,0 +1,311 @@ +# A conditional completed ordinary API implication for the first4814 backend edge + +This proves one source-bound implication, not the all-size native/compiler/tape +premises themselves. It audits A0(4760)->A1(4814), with actual helper462/frame506 +as its concrete whole-job witness. The original supplier-boundary-audit card, +its explicit donor refinement, main pin and public4945 scope are retained in +the immutable proposal above this implementation directory. + +## 1. Quantified premises and conclusion + +Freeze4760 ecdfcabd56dfa663ae020733f9f1a88c6644743c and4814 +f56ae4533a7d97d782a2c596a33fe844cd051747. Before varying the argument width, +fix the finite compiled word, its ambient N, all rational projector/matcher +matrices, distinct physical owners, finite route/precision/tape constants and +an odd prime avoiding their denominators and determinant witnesses. Retain: + +P1. The actual native finite word, chronological tensor/compiler and complete +whole-job implementation compute their stated projector endpoints on arbitrary +inputs, preserve complete spectator fields and restore their external ROW +coordinate. Product copies use distinct physical arrays; owned state remains +allocated until safe erasure. These are the source's explicit conditional +native/compiler hypotheses, not results of this experiment. + +P2. The inherited completed OLD ordinary atom supplier handles arbitrary widths, +two complete argument chunks, arbitrary preceding/intervening complete spectators, +and internally borrowed/restored ROW stock. The fixed-rational ordered-affine, +unit-scaling, controlled-shift and finite low-type routing lemmas have their +stated physical costs. No arbitrary address oracle or dense same-ARRAY map is +admitted. For4760 this older atom supplier has saving.0000384599. + +P3. The source stopped recurrence and reserve bound hold with the NEW fixed +program constants, not earlier numerical thresholds. The uniform4760/4814 +compiler and full delayed-cover fallback have the retained source hypotheses. +Ordinary data storage is initialized and padding/removal is charged. The +remaining analytic, prime, physical tape and outer premises are not discharged. + +Then the4760 construction of A0 has the completed ordinary type needed by the +FIRST4814 A1 backend edge: every A0 occurrence replaces an ordinary chunk +interchange with complete spectators and restored external ROW, using its own +argument chunks for internal stock. It needs no externally supplied new zero +ROW and no common inner/outer prime. The replacement preserves all fixed route, +weighted-leaf, high-part and padding costs. For the fixed three-level acyclic +chain, its type and positive exponent gaps propagate by finite induction. +This is a conditional composition proof with no new native invoice or kappa. + +The premises matter: accepting P1's ROW/physical ownership contract is not an +independent implementation proof of that full compiler. If a literal source +operation violates P1/P2, the conclusion cannot be used. We do not change the +original4814 record's actual_backend_API_independently_verified flag or call +an archive merge scientific acceptance. + +## 2. Actual partial helper and all positive column widths + +Helper462 is an arbitrary original input starting at frame0 and ending at +frame506, with rank4. Read its rational B (image rows) and A (kernel rows) +from the exact source frame bank. Set + + P = B^T (B B^T)^-1 B, + S = [B^T | A^T], Q=diag(I4,0). + +The rowspaces are complementary and orthogonal in this actual frame, so S is +invertible, P^2=P, and S Q S^-1=P. Our code reconstructs these matrices from +source bytes without importing the predecessor helper_matchers function. +For positive f, let Pf=P tensor I_f, Sf=S tensor I_f. With actual reversal +C_(8f)=C8 tensor C_f, define + + D_P = [ I-P P C ], Q_S=diag(S,C S C). + [ C P I-C P C ] + +Block multiplication gives Q_S D_Q Q_S^-1=D_P. Kronecker multiplication and +C_f^2=I give the same identity for every f. The source's rank4 job becomes +rank4f with identity spectators; it is not a rank8f job. These equalities are +linear coordinate permutations after valid reduction to the source local +ring; equality of the coordinate maps implies equality on arbitrary input +functions. No inference from a few special Boolean data inputs is needed. + +Let a parent request be D_(gPg^-1) on the complete cover row g, and the child +canonical target be D_(hQh^-1). Push the parent's whole role fiber to h=gS, +execute the complete child and return by S^-1. Then + + (gS) Q (gS)^-1 = g P g^-1. + +Right multiplication by the invertible fixed S is a bijection of the entire +GL cover, so no arbitrary input is discarded/copied or assumed zero. Source +'gather' notation can list S^-1 for the input address lookup; our statement +uses the explicit push convention above. Both routes remain paid. + +At f1/f2, small witnesses modulo25 and49 compare the canonical routed physical +operator, applied to every linear coordinate basis vector, with a separately +implemented direct projector action. There are384 such basis-column checks. +These small rings do not replace the actual q>2^45 N^5 rule. The proof is over +the rational identities and valid local-ring reductions at every width. + +## 3. Weights, complete cover rows and real carries + +The parent's external unit weight may depend on exposed ancestor coordinates +and column index but is independent of the current fresh cover row/roles. +Its address map Lambda=diag(A,I) therefore commutes with the fiber route: +the route changes g only and Lambda has the same value before/after it. This +is an equality of two maps on the product domain, not a claim that arbitrary +matrix S commutes with a diagonal matrix A on one ARRAY. Conjugating the +whole routed word gives the requested weighted projector endpoint. + +A leaf weight can depend on the current OUTER g because that g is a spectator +ancestor of the INNER call. It must remain independent of the inner fresh row. +An inner ordinary call receives all outer row/head/type fields as complete +spectators; its own stock is disjoint. This is exactly the completed type in +P1/P2, not a heterogeneous-weight supplier assumption. The finite control uses +a nonzero address and two actual row representatives to show that a weight +illegally reading the fresh row produces unequal route/weight composites. + +Write g=g0+qG1. For a fixed rational matcher reduced modulo q^w, let +h0=(g0 S) mod q. The high-coordinate map is + + G1 -> G1 S + (g0 S-h0)/q (mod q^(w-1)). + +For each finite low type g0, every entry of G1 ranges independently over the +complete local ring; invertibility depends only on g0. Thus ordinary chunk +operations see complete ranges and all other high entries as spectators. +The carry is determined by the fixed low type and source matcher and is +charged. The code separately reconstructs this formula at w2 with nonzero +high matrix and rejects dropping its actual carry. A finite low-type +permutation is also paid; it is not an unpriced gather. + +For this S, deterministic rational elimination yields5 swaps,5 unit scalings +and14 shears, and reconstructs S in the exact chronological right-product +order. On the8-row high matrix, ONE route consequently uses40 ordinary chunk +interchanges,40 fixed unit scalings,112 linear ordered shifts and at most64 +carry shifts, plus one finite low-type permutation. Its inverse has the same +conservative counts. The PAIR ledger is80 ordinary interchanges,80 scalings, +224 linear shifts, at most128 carry shifts and2 low-type permutations. +The tensor multiplicity f does not enlarge the8-dimensional cover row. +An embedding into a fixed larger compiler N gives a finite constructive count +by the same elimination and high-row algorithm. The count depends on that +fixed program; it is not assumed uniformly constant as N changes. + +Each ordinary interchange uses the completed backend with the other high +coordinates/low type as spectators. The ordered-affine/unit-scaling primitive +cost remains inherited P2, explicitly charged. The finite low-type permutation +can be generated by a finite table/cycle decomposition, whose size is bounded +by |GL_N(F_q)|; its source physical routing implementation is retained. We +have not executed the astronomical compiled routing list or independently +proved P2's tape realization. Their charges remain finite algorithm-derived +constants, never zero. + +## 4. Weighted atoms consume exactly the available completed API + +For every unit a in a commutative source local ring, let + + J1=[0 1;1 0], L(b)=[1 0;b 1], U(a)=[1 a;0 1]. + +The exact identities are U(a)=J1 L(a) J1 and + + Ja=diag(1,-1) U(a) L(-a^-1) U(a)=[0 a;a^-1 0]. + +Consequently the chronological literal word uses4 OLD ordinary J1 calls, +3 prefix-controlled shifts and1 fixed sign. It requires no weighted backend +primitive. Every J1 exchanges two complete atom chunks with all descriptor/ +ancestor/ROW fields as spectators. Unequal inner prime is handled at the +completed ordinary endpoint, as below. The code checks this exact word over +rational units2 and3 and rejects deleting an actual J1. It does not replace +Ja by an oracle or assume differently weighted internal jobs can mix. + +## 5. Completed ordinary body and two ROW levels + +For any module of chunk coordinates and any reversal involution C, assume a +completed raw body F_n(H,D)=(C D,C H) preserves its external ROW/spectators. +Trace the actual chronological source wrapper: + + D-=H; F_n; D+=H; F_n; D=H-D. + +Starting at arbitrary H,D its states are +(H,D-H), (C(D-H),C H), (C(D-H),C D), (D,D-H), (D,H). +External fields are unchanged at every raw-call return. Three additive maps +are charged and the two completed F_n calls reuse the same restored reserve. +Their fixed multiplicity is outside the stopped recurrence, not a factor +inserted into every characteristic-moment branch. + +Borrowing is also explicit. Split the original complete argument chunks as +H=(H_hi,H_body), D=(D_hi,D_body). Reinterpret H_hi as the preceding ROW for +the ordinary body call; D_hi and original intervening Z remain spectators. +After the completed body the state is + + H_hi, D_body, Z, D_hi, H_body. + +Restore/unpad the ROW before the completed high-part interchange, then swap +H_hi,D_hi with the bodies/Z as spectators. The exact result is D,Z,H. The +borrowed high data was arbitrary original data; it was neither initialized +nor discarded. With k=ceil(log_q S(e,w))=O(w log e), k=S. Those constants +multiply only finitely in three named levels, not once per coarse recursion +node. The completed genuine-rectangle invariant permits unpadding at each +return boundary. Every initialization, retention and removal remains paid. + +The small witnesses use q5/q7,w2, padding25 to32 and49 to64, giving paired +volume ratios1024/625 and4096/2401, each<4. A row divisor3 pads the row ranges +to27 and51, charging2 owned added rows in each case. These are type fixtures, +not actual large-q compiler executions or practical stock thresholds. Replacing +the completed endpoint by the source odd-radix atom-reversed body maps the +genuine rectangle out of itself. For caller range25, use inner radix7 with +2 atoms (range49); for caller range49, use inner radix5 with3 atoms (range125). +These full cross-radix factors are2401/625 and15625/2401, respectively. They +include the separately charged inner fixed-radix conversion and are not +claimed below4: that bound applies only to the two binary padding ranges. +The returned counterexample addresses are retained in RESULT.json; this +rejection is not a synthetic malformed padding label. This provides a discriminating reason the source's completed boundary +is necessary. + +## 7. Complete first-edge price type and finite chain + +No raw rank/profile changes occur. The inherited4760 caller retains11400 +original owners,57339 paid queries and7848 global helper originals; +its local supplier has436 independent helpers. +All nine paid rank7 COPY episodes per local FULL remain charged. There are +72 partial rank4 output jobs,144 added matcher routes and7548 other raw +nonidentity port routes. Their sum7692 is a RAW route census, not the count +after uniform compilation. + +Every fixed compiled matcher pair consumes its paid completed ordinary route, +fixed shifts/scalings/carries and owned movement. Every weighted leaf consumes +4 ordinary atom interchanges. Cover fallback remains paid with the source +2N^3/q fraction and up to32N^2 bad children, under the new fixed large-prime +budget. Target completion and splitting are unchanged. No new productive +credit is introduced by padding, ROW or copies. + +Set b0=.0034597,rho=.01,C1=.00347545805-(2^-36+10^-20). By P1-P3, after fixing +all new finite constants, the three root costs have the source form + + O(V[e^(1-rho) + +e^((1-rho)(1-C1)+rho(1-b0)) + +e^rho log e]). + +The middle exponent is1-a1 for a1=(1-rho)C1+rho b0. Actual computed rational +gaps establish b02^45 N^5, a compiler-size test or a stock threshold. +- Seven independent boundary controls reject an omitted matcher, omitted column + tail reversal, fresh-ROW-dependent weight, inner ROW alias, missing weighted + leaf swap, premature unpadding after the source odd-radix raw reversed body and dropped + high-matrix carry. Comparisons use coordinate actions or returned states; + they do not merely compare two copies of the asserted equality. + +The finite code corroborates the generic proof. It does not infer universal +arbitrary-input correctness solely from those22 cases. No full658/11400 RAW +native replay or astronomical compiled program was executed. + +## Complete cost boundary + +All4760 ranks remain unchanged:11400 original owners,57339 paid queries, +7848 helper originals, all nine rank7 COPY charges per local FULL retained. +The144 added partial-helper matching routes and7548 inherited port routes +remain paid; their raw total7692 is not a final compiled count. + +For the selected coarse8-dimensional matcher pair, explicit high-matrix +routing uses80 completed ordinary chunk interchanges,80 fixed unit scalings, +224 linear ordered shifts, at most128 carry shifts and2 finite low-type +permutations. Each is charged by the source fixed-rational routing primitive; +the two low-type permutations and their finite table/cycle costs remain +separate. This is a conservative constructive bound, not a practical tape +constant or a reduction of the inherited route count. For a fixed larger +compiled N, the same finite elimination/high-row algorithm gives its new +N-dependent constant before argument width varies. + +Every weighted atom uses4 completed ordinary swaps,3 controlled shifts and +1 fixed sign. Every completed ordinary body uses2 completed raw bodies and +3 additions; high-part exchange, row/radix padding, stock initialization and +removal, owned erasure, completion/splitting and full bad-class fallback remain +charged. Positive existing adapter/stock/relaxation gaps absorb fixed +constructively bounded constants, not an unknown asymptotic operation. + +Given the retained primitive bounds, the first-edge root costs remain + + O(V[e^.99 + e^(.99(1-C1)+.01(1-.0034597)) + e^.01 log e]), + +where C1=.00347545805-(2^-36+10^-20). The written proof then freezes each +backend before the next and obtains the existing finite3-level induction. +Exact Fraction checks reproduce the already declared stage gaps; no new +exponent is extracted. This validates the composition's type/cost implication +inside its conditional model, not a complete ordinary supplier implementation. + +## What still blocks full independent admission + +The actual finite native/compiler program's ROW restoration and distinct +physical allocation at all widths, the source ordered-affine/scaling/tape +implementation, generated precision/machine constants and analytic/outer +recovery remain inherited. They are explicitly P1-P3 in PROOF.md. The code +sets full4814_primitive_API_independently_proved=False. If an unconditional or +complete physical API audit is desired, it needs a literal source-bound +N-dimensional physical stock/role/route generator satisfying those premises. +Another root evaluation or this local fixture cannot supply it. + +The current positive result can strengthen the justification that4814's +conditional ordinary.003475458 uses no stronger completed interface than its +retained source allows. It cannot independently promote that record from an +archival/partially-reviewed status, prove the underlying BIT machine or raise +the global bound while the complex supplier binds. Separate4940 work remains +primary. Independent review is required before the root treats this finding +as accepted; this packet contains author checks only until that review lands. + +## Reproduction and source/credit + +Read-only from the worktree root: + + python3 -I -B outputs/bit-completed-backend-api-gate/implementation/check.py + python3 -I -O -B outputs/bit-completed-backend-api-gate/implementation/check.py + +Explicit --write writes only RESULT.json and implementation/SOURCES.json. +The script fetches immutable source Git objects; no network, primary checker +import or shared source write is performed. Normal/O stdout must match. +The formal typed inner raw contract in the fixtures is clearly labelled; +it is not a disguised claim to execute the actual full compiler. + +Credit ai-nanachi4760/4814/4326; rohanarun185/199 and Maxime Fleury204; +Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612, +and the retained whole-job/ROW/native/precision/tape/outer lineage. New4944 +(physically typed CRT placement) and4942 (that callee's branch threshold) +are neighboring source-bound uses, not this completed-backend proof; their +CRT layouts and threshold calculations are not repeated. Substantial OpenAI +Codex assistance, Apache-2.0. No human or proof-kernel review is claimed. + +## Preserved first freeze and corrected negative controls + +The initial local seven-file freeze remains unchanged under +history/prior-controls/. Independent reviewer B found that the wrong-tail +control checked only unequal reversal matrices, and the padding control used +binary reversal instead of the source odd-radix raw F_n. The current controls +compare a mutated physical endpoint after the correct source routes, and +source-typed C2/C3 cross-radix returns25→49 (base7) and49→125 (base5). +Actual failing coordinates/addresses are recorded. Their full padding factors +include the separately charged inner-radix conversion; they are not called +less than4. The positive22 fixtures,384 columns, written generic proof and +price/type conclusions are unchanged. The correction does not claim the +old two weaker controls established the same coverage. diff --git a/research/bit-completed-backend-api/independent/corrected/RESULT.json b/research/bit-completed-backend-api/independent/corrected/RESULT.json new file mode 100644 index 0000000000..55dca30281 --- /dev/null +++ b/research/bit-completed-backend-api/independent/corrected/RESULT.json @@ -0,0 +1,2542 @@ +{ + "all_width_proof": "See PROOF.md; finite fixtures are corroboration only", + "arbitrary_data_scope": "Exact coordinate operator identities + written universal permutation/interface proof; no full arrays or astronomical template executed", + "column_multiplicities": [ + 1, + 2 + ], + "controls": { + "fresh_ROW_weight": true, + "inner_ROW_alias": true, + "omit_column_tail_reversal": { + "actual": "0", + "basis_column": 26, + "output_coordinate": 2, + "wrong": "1/2" + }, + "omit_high_matrix_carry": true, + "omit_matcher": true, + "omit_weighted_leaf_swap": true, + "premature_padding_cleanup": [ + { + "caller_radix": 5, + "genuine_range": 25, + "inner_radix": 7, + "inner_width": 2, + "input": [ + 0, + 4 + ], + "padded_inner_range": 49, + "raw_output": [ + 28, + 0 + ] + }, + { + "caller_radix": 7, + "genuine_range": 49, + "inner_radix": 5, + "inner_width": 3, + "input": [ + 0, + 2 + ], + "padded_inner_range": 125, + "raw_output": [ + 50, + 0 + ] + } + ] + }, + "finite_levels": [ + { + "adapter_gap": "4276027093749855738909939/655360000000000000000000000", + "admitted": "8688251/2500000000", + "backend": "34597/10000000", + "exact": "2277572906250144261090061/655360000000000000000000000", + "relaxation_gap": "36106144261090061/655360000000000000000000000", + "stock_gap": "646528827093749855738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275924854968415738909939/655360000000000000000000000", + "admitted": "8688641/2500000000", + "backend": "8688251/2500000000", + "exact": "2277675145031584261090061/655360000000000000000000000", + "relaxation_gap": "38727584261090061/655360000000000000000000000", + "stock_gap": "646528724854968415738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275923832606815738909939/655360000000000000000000000", + "admitted": "1737729/500000000", + "backend": "8688641/2500000000", + "exact": "2277676167393184261090061/655360000000000000000000000", + "relaxation_gap": "12513184261090061/655360000000000000000000000", + "stock_gap": "646528723832606815738909939/655360000000000000000000000" + } + ], + "fixture_cap": 64, + "fixtures": [ + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + } + ], + "full4814_primitive_API_independently_proved": false, + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "native_rawbody_ROW_semantics": "Inherited premise; wrapper proof checks its exact use, not actual full compiler implementation", + "new_kappa": false, + "original_helper": 462, + "padding_fixtures": [ + { + "binary_range": 32, + "digit_width": 2, + "full_cross_radix_volume_factor": "2401/625", + "inner_padded_range": 49, + "inner_radix": 7, + "inner_width": 2, + "owned_padded_rows": 2, + "padded_row_range": 27, + "radix": 5, + "range": 25, + "row_divisor": 3, + "two_range_volume_factor": "1024/625" + }, + { + "binary_range": 64, + "digit_width": 2, + "full_cross_radix_volume_factor": "15625/2401", + "inner_padded_range": 125, + "inner_radix": 5, + "inner_width": 3, + "owned_padded_rows": 2, + "padded_row_range": 51, + "radix": 7, + "range": 49, + "row_divisor": 3, + "two_range_volume_factor": "4096/2401" + } + ], + "physical_basis_columns_checked": 384, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "right_route_elimination_counts": { + "add": 14, + "scale": 5, + "swap": 5 + }, + "right_route_factors": [ + [ + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "2", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + ], + "routing_cost_primitive": "Inherited fixed-rational ordered-affine/scaling/shift lemma; every elementary factor is charged", + "selected_record_changed": false, + "selected_route_pair_high_matrix_ledger": { + "carry_ordered_shifts_upper": 128, + "fixed_unit_scalings": 80, + "linear_ordered_shifts": 224, + "low_type_permutations": 2, + "ordinary_chunk_interchanges": 80, + "scope": "N=8 coarse head; all charged; low-type finite-permutation costs separate; tensor f does not enlarge cover row dimension" + }, + "small_fixtures": 22, + "source_frame": 506, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "status": "PASS_ONE_CONDITIONAL_A0_TO_A1_API_IMPLICATION_NOT_PRIMITIVE_ADMISSION", + "weighted_leaf_fixtures": [ + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 3 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 3 + } + ] +} diff --git a/research/bit-completed-backend-api/independent/corrected/SOURCES.json b/research/bit-completed-backend-api/independent/corrected/SOURCES.json new file mode 100644 index 0000000000..27666c7299 --- /dev/null +++ b/research/bit-completed-backend-api/independent/corrected/SOURCES.json @@ -0,0 +1,15 @@ +{ + "checker_sha256": "0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e", + "files": { + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "research/bit-finite-ordinary-bootstrap/PROOF.md": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "research/bit-finite-ordinary-bootstrap/RECORD.json": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "research/bit-finite-ordinary-bootstrap/independent.py": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "schema_version": 1, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747" +} diff --git a/research/bit-completed-backend-api/independent/corrected/check.py b/research/bit-completed-backend-api/independent/corrected/check.py new file mode 100644 index 0000000000..74ee4911f1 --- /dev/null +++ b/research/bit-completed-backend-api/independent/corrected/check.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python3 +"""One source-bound conditional completed ordinary backend API gate. +No predecessor executable/price engine imported. Apache-2.0; Codex assistance. +""" +from pathlib import Path +from fractions import Fraction as F +from hashlib import sha256 +from collections import Counter +import json,subprocess,sys +HERE=Path(__file__).resolve().parent +PIN='f56ae4533a7d97d782a2c596a33fe844cd051747' +PATHS={'frames':'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json','word':'research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz','proof':'research/bit-finite-ordinary-bootstrap/PROOF.md','independent':'research/bit-finite-ordinary-bootstrap/independent.py','bridge':'research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md','bit':'notes/three-stage-cover-bit.tex','rows':'notes/three-stage-cover-rows.tex','record':'research/bit-finite-ordinary-bootstrap/RECORD.json'} +def need(x,m): + if not x:raise ValueError(m) +def eye(n):return [[F(i==j)for j in range(n)]for i in range(n)] +def tr(a):return list(map(list,zip(*a))) +def mm(a,b):return [[sum((x*y for x,y in zip(r,c)),F(0))for c in zip(*b)]for r in a] +def add(a,b,k=1):return [[x+k*y for x,y in zip(r,s)]for r,s in zip(a,b)] +def inverse(a): + n=len(a);w=[list(r)+e for r,e in zip(a,eye(n))] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]);w[j],w[k]=w[k],w[j];v=w[j][j];w[j]=[x/v for x in w[j]] + for i in range(n): + if i!=j: + z=w[i][j];w[i]=[x-z*y for x,y in zip(w[i],w[j])] + return [r[n:]for r in w] +def kron(a,f):return [[a[i//f][j//f]*F(i%f==j%f)for j in range(len(a[0])*f)]for i in range(len(a)*f)] +def paired(p): + n=len(p);c=[[F(i+j==n-1)for j in range(n)]for i in range(n)];u=add(eye(n),p,-1) + return [x+y for x,y in zip(u,mm(p,c))]+[x+y for x,y in zip(mm(c,p),mm(mm(c,u),c))] +def paired_map(s): + n=len(s);z=[[F(0)]*n for _ in range(n)];c=[[F(i+j==n-1)for j in range(n)]for i in range(n)] + return [x+y for x,y in zip(s,z)]+[x+y for x,y in zip(z,mm(mm(c,s),c))] +def mod(a,m):return [[(x.numerator*pow(x.denominator,-1,m))%m for x in r]for r in a] +def mv(a,v,m):return [sum(x*y for x,y in zip(r,v))%m for r in a] +def direct_action(p,v,m): + # Independently apply the actual projector law coordinate-by-coordinate. + n=len(p);h,t=v[:n],v[n:];ph=mv(p,h,m);pct=mv(p,list(reversed(t)),m) + return [(h[i]-ph[i]+pct[i])%m for i in range(n)]+[(t[i]+ph[n-1-i]-pct[n-1-i])%m for i in range(n)] +def decompose(s): + w=[r[:]for r in s];n=len(s);ops=[] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]) + if k!=j:w[j],w[k]=w[k],w[j];ops.append(('swap',j,k,F(1))) + v=w[j][j] + if v!=1:w[j]=[x/v for x in w[j]];ops.append(('scale',j,j,1/v)) + for i in range(n): + if i!=j and w[i][j]: + z=-w[i][j];w[i]=[x+z*y for x,y in zip(w[i],w[j])];ops.append(('add',i,j,z)) + need(w==eye(n),'deterministic rational elimination') + factors=[] + for typ,i,j,z in ops: + e=eye(n) + if typ=='swap':e[i],e[j]=e[j],e[i] + elif typ=='scale':e[i][i]=1/z + else:e[i][j]=-z + factors.append(e) + out=eye(n) + for e in factors:out=mm(out,e) + need(out==s,'literal right multiplier factor order') + return ops,factors + +def wrapper(h,d,rows,raw): + # Source exact completed ordinary body; rows are read-only spectators of raw. + h=list(h);d=[y-x for x,y in zip(h,d)];h,d,r=raw(h,d,rows) + d=[x+y for x,y in zip(d,h)];h,d,r=raw(h,d,r) + d=[x-y for x,y in zip(h,d)] + return h,d,r + +def main(): + raw={k:subprocess.check_output(['git','--no-replace-objects','show',PIN+':'+p])for k,p in PATHS.items()} + need(sha256(raw['frames']).hexdigest()=='d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010','actual source frame bank') + import gzip + word=json.loads(gzip.decompress(raw['word']));frame=json.loads(raw['frames'])['frames']['506'] + need(word['start'][462]==0 and word['final'][462]==506 and frame['dim']==4,'actual arbitrary helper462 rank4') + B=[[F(x)for x in r]for r in frame['B']];A=[[F(x)for x in r]for r in frame['A']] + P=mm(mm(tr(B),inverse(mm(B,tr(B)))),B);S=tr(B+A);Si=inverse(S);Q=[[F(i==j and i<4)for j in range(8)]for i in range(8)] + need(mm(P,P)==P and mm(mm(S,Q),Si)==P,'source rational idempotent and matcher') + ops,factors=decompose(S);need(all(x.denominator%5 and x.denominator%7 for r in S+Si+P for x in r),'declared fixture primes valid') + controls={};fixtures=[];basis_columns=0 + for f in (1,2): + Pf,Sf,Qf=kron(P,f),kron(S,f),kron(Q,f);n=8*f;Sfi=inverse(Sf) + need(mm(mm(paired_map(Sf),paired(Qf)),paired_map(Sfi))==paired(Pf),'actual reversed-tail all-f tensor form in fixture') + # This wrong C8 tensor I_f must fail at f2, unless accidentally symmetric. + if f==2: + wrong=[[F(i//f+j//f==7 and i%f==j%f)for j in range(n)]for i in range(n)] + # Mutate the actual canonical child's tail pairing, then use the + # correct source routes; compare the returned physical endpoint. + u=add(eye(n),Qf,-1) + wrong_child=[x+y for x,y in zip(u,mm(Qf,wrong))]+[x+y for x,y in zip(mm(wrong,Qf),add(eye(n),mm(mm(wrong,Qf),wrong),-1))] + wrong_endpoint=mm(mm(paired_map(Sf),wrong_child),paired_map(Sfi)) + actual_endpoint=paired(Pf) + mismatch=next((i,j)for i in range(2*n)for j in range(2*n)if wrong_endpoint[i][j]!=actual_endpoint[i][j]) + need(wrong_endpoint!=actual_endpoint,'wrong tail actual returned physical operator fails') + controls['omit_column_tail_reversal']={'basis_column':mismatch[1],'output_coordinate':mismatch[0],'wrong':str(wrong_endpoint[mismatch[0]][mismatch[1]]),'actual':str(actual_endpoint[mismatch[0]][mismatch[1]])} + for prime in (5,7): + m=prime**2 + for variant in (0,1): + g=eye(8);g[0][1]=F(variant);gi=inverse(g);h=mm(g,S) + gp=mm(mm(g,P),gi);hq=mm(mm(h,Q),inverse(h));need(gp==hq,'whole cover route g to gS correct') + need(mm(h,Si)==g,'exact row inverse return') + # A genuinely independent coordinate path: route via gS,Q then undo vs + # direct requested projector gPg^-1 on every linear coordinate basis. + routed=paired_map(kron(h,f));unroute=paired_map(kron(inverse(h),f));canonical=paired(Qf) + dp=mod(kron(gp,f),m);ri=mod(unroute,m);rc=mod(canonical,m);ro=mod(routed,m) + # Independent q-adic high-matrix route/carry, with fixed nonzero high part. + g0=mod(g,prime);G1=[[0]*8 for _ in range(8)];G1[1][0]=1 + sm=mod(S,m);slow=mod(S,prime) + gw=[[g0[i][j]+prime*G1[i][j]for j in range(8)]for i in range(8)] + direct=mod(mm(gw,sm),m);z=mm(g0,sm) + low=[[int(x)%prime for x in row]for row in z] + carry=[[(int(z[i][j])-low[i][j])//prime%prime for j in range(8)]for i in range(8)] + linear=mod(mm(G1,slow),prime) + high=[[(linear[i][j]+carry[i][j])%prime for j in range(8)]for i in range(8)] + rebuilt=[[low[i][j]+prime*high[i][j]for j in range(8)]for i in range(8)] + need(direct==rebuilt,'actual whole-cover high affine route including carry') + without=[[low[i][j]+prime*linear[i][j]for j in range(8)]for i in range(8)] + need(without!=direct,'omitting real route carry fails') + controls['omit_high_matrix_carry']=True + for ancestor in (0,1): + weights=[1+(i+ancestor)%2 for i in range(n)] + lam=eye(2*n);lami=eye(2*n) + for i,a in enumerate(weights):lam[i][i]=a;lami[i][i]=F(1,a) + lm,li=mod(lam,m),mod(lami,m) + for j in range(2*n): + v=[int(i==j)for i in range(2*n)] + lhs=mv(lm,mv(ro,mv(rc,mv(ri,mv(li,v,m),m),m),m),m) + rhs=mv(lm,direct_action(dp,mv(li,v,m),m),m) + need(lhs==rhs,'independent all-basis weighted physical helper route') + basis_columns+=1 + # Two visible ROW levels + a complete spectator, held by the raw contract. + r={'outer':(prime,variant),'inner':(ancestor,prime+1),'spectator':(3,7,11)} + x=[F(i+1)for i in range(n)];y=[F(2*i-3)for i in range(n)] + rawbody=lambda a,b,row:(list(reversed(b)),list(reversed(a)),dict(row)) + def inner_completed(a,b,row): + # Inner ROW is borrowed from the CURRENT argument's own high part, + # not a new arbitrary owner or externally supplied empty stock. + ah,bh=list(a[:1]),list(b[:1]);ar,br=list(a[1:]),list(b[1:]) + borrowed=dict(row);borrowed['borrowed_inner_ROW']=tuple(ah) + ao,bo,ret=wrapper(ar,br,borrowed,rawbody) + need(ret==borrowed,'inner completed body restores borrowed/current high ROW') + del ret['borrowed_inner_ROW'] + # One completed high-part interchange, after ROW restoration. + return bh+ao,ah+bo,ret + def nested_raw(a,b,row): + aa,bb,ret=inner_completed(a,b,row) + return list(reversed(aa)),list(reversed(bb)),ret + xo,yo,rr=wrapper(x,y,r,nested_raw) + need(xo==y and yo==x and rr==r,'completed wrapper arbitrary typed ROWs') + # The second nesting order is a control: overwrite outer row by inner. + def badbody(a,b,row): + row=dict(row);row['outer']=row['inner'];return list(reversed(b)),list(reversed(a)),row + _,_,bad=wrapper(x,y,r,badbody);need(bad!=r,'unrestored/aliased ROW control') + controls['inner_ROW_alias']=True + fixtures.append({'f':f,'prime':prime,'modulus':m,'g_variant':variant,'ancestor':ancestor,'basis_columns':2*n,'two_ROW_levels_preserved':True,'inner_stock_borrowed_from_argument':True}) + # Non-tautological fresh weight failure: the route changes the row queried + # by the illegal weight. Choose the already declared variant1, no search. + g=eye(8);g[0][1]=1;h=mm(g,S) + fresh=lambda z:1+int(z[0][1]==0) + need(fresh(g)!=fresh(h),'fresh-row weight descriptor changes on actual route') + address=[1]+[0]*15 + left=(tuple(map(tuple,h)),fresh(g)*address[0]) + right=(tuple(map(tuple,h)),fresh(h)*address[0]) + need(left!=right,'actual fresh-row scaling and route commutator on nonzero address') + controls['fresh_ROW_weight']=True + # Four OLD ordinary swaps, three shifts, one fixed sign; exact modular word. + I=eye(2);J=[[F(0),F(1)],[F(1),F(0)]] + def L(a):return [[F(1),F(0)],[F(a),F(1)]] + sig=[[F(1),F(0)],[F(0),F(-1)]];weighted=[] + for prime in (5,7): + m=prime**2 + for a in (2,3): + aa=F(a);word=[J,L(aa),J,L(-1/aa),J,L(aa),J,sig] + op=I + for e in word:op=mm(e,op) + expected=[[F(0),aa],[1/aa,F(0)]] + need(op==expected,'literal4 ordinary weighted leaf swaps') + bad=I + for k,e in enumerate(word): + if k!=0:bad=mm(e,bad) + need(bad!=expected,'omitted ordinary atom interchange') + controls['omit_weighted_leaf_swap']=True;weighted.append({'prime':prime,'unit':a,'ordinary_swaps':4,'shifts':3,'signs':1}) + # Padding uses the invariant genuine rectangle, not an assumed inverse of + # an internally uncompleted body. These address permutations are independent + # of the rational matrix helper checks above. + padding=[] + for radix in (5,7): + original=radix**2;padded=1<<(original-1).bit_length();need(padded<2*original,'two chunk binary pad bound') + genuinely=set((i,j)for i in range(original)for j in range(original));returned={(j,i)for i,j in genuinely} + need(returned==genuinely,'completed ordinary swap preserves genuine rectangle') + need(all((i=row_stock and row_padded<2*source,'owned ROW pad bound') + # Source F_n reverses ODD-RADIX atom positions, not binary bits. + # Keep caller radix5/7 and use the other declared prime internally. + inner=7 if radix==5 else 5;inner_width=2 if radix==5 else 3;inner_range=inner**inner_width + def rev(n): + out=0 + for _ in range(inner_width):out=out*inner+n%inner;n//=inner + return out + bad={(rev(j),rev(i))for i,j in genuinely} + need(bad!=genuinely,'source odd-radix raw reversed body violates genuine rectangle') + witness=next((i,j)for i in range(original)for j in range(original)if rev(j)>=original or rev(i)>=original) + controls.setdefault('premature_padding_cleanup',[]).append({'caller_radix':radix,'genuine_range':original,'inner_radix':inner,'inner_width':inner_width,'padded_inner_range':inner_range,'input':list(witness),'raw_output':[rev(witness[1]),rev(witness[0])]}) + padding.append({'radix':radix,'digit_width':2,'range':original,'binary_range':padded,'two_range_volume_factor':str(F(padded**2,original**2)),'inner_radix':inner,'inner_width':inner_width,'inner_padded_range':inner_range,'full_cross_radix_volume_factor':str(F(inner_range**2,original**2)),'row_divisor':row_stock,'padded_row_range':row_padded,'owned_padded_rows':row_padded-source}) + # Reject omitted physical whole-job matcher with actual matrices. + controls['omit_matcher']=paired(Q)!=paired(P) + need(all(controls.values()),'every semantic control distinguishes') + C1=F('.00347545805')-F(1,2**36)-F(1,10**20);rho=F(1,100);b=F('.0034597');levels=[] + for value in (F('.0034753004'),F('.0034754564'),F('.0034754580')): + a=(1-rho)*C1+rho*b;need(bA1(4814), with actual helper462/frame506 +as its concrete whole-job witness. The original supplier-boundary-audit card, +its explicit donor refinement, main pin and public4945 scope are retained in +the immutable proposal above this implementation directory. + +## 1. Quantified premises and conclusion + +Freeze4760 ecdfcabd56dfa663ae020733f9f1a88c6644743c and4814 +f56ae4533a7d97d782a2c596a33fe844cd051747. Before varying the argument width, +fix the finite compiled word, its ambient N, all rational projector/matcher +matrices, distinct physical owners, finite route/precision/tape constants and +an odd prime avoiding their denominators and determinant witnesses. Retain: + +P1. The actual native finite word, chronological tensor/compiler and complete +whole-job implementation compute their stated projector endpoints on arbitrary +inputs, preserve complete spectator fields and restore their external ROW +coordinate. Product copies use distinct physical arrays; owned state remains +allocated until safe erasure. These are the source's explicit conditional +native/compiler hypotheses, not results of this experiment. + +P2. The inherited completed OLD ordinary atom supplier handles arbitrary widths, +two complete argument chunks, arbitrary preceding/intervening complete spectators, +and internally borrowed/restored ROW stock. The fixed-rational ordered-affine, +unit-scaling, controlled-shift and finite low-type routing lemmas have their +stated physical costs. No arbitrary address oracle or dense same-ARRAY map is +admitted. For4760 this older atom supplier has saving.0000384599. + +P3. The source stopped recurrence and reserve bound hold with the NEW fixed +program constants, not earlier numerical thresholds. The uniform4760/4814 +compiler and full delayed-cover fallback have the retained source hypotheses. +Ordinary data storage is initialized and padding/removal is charged. The +remaining analytic, prime, physical tape and outer premises are not discharged. + +Then the4760 construction of A0 has the completed ordinary type needed by the +FIRST4814 A1 backend edge: every A0 occurrence replaces an ordinary chunk +interchange with complete spectators and restored external ROW, using its own +argument chunks for internal stock. It needs no externally supplied new zero +ROW and no common inner/outer prime. The replacement preserves all fixed route, +weighted-leaf, high-part and padding costs. For the fixed three-level acyclic +chain, its type and positive exponent gaps propagate by finite induction. +This is a conditional composition proof with no new native invoice or kappa. + +The premises matter: accepting P1's ROW/physical ownership contract is not an +independent implementation proof of that full compiler. If a literal source +operation violates P1/P2, the conclusion cannot be used. We do not change the +original4814 record's actual_backend_API_independently_verified flag or call +an archive merge scientific acceptance. + +## 2. Actual partial helper and all positive column widths + +Helper462 is an arbitrary original input starting at frame0 and ending at +frame506, with rank4. Read its rational B (image rows) and A (kernel rows) +from the exact source frame bank. Set + + P = B^T (B B^T)^-1 B, + S = [B^T | A^T], Q=diag(I4,0). + +The rowspaces are complementary and orthogonal in this actual frame, so S is +invertible, P^2=P, and S Q S^-1=P. Our code reconstructs these matrices from +source bytes without importing the predecessor helper_matchers function. +For positive f, let Pf=P tensor I_f, Sf=S tensor I_f. With actual reversal +C_(8f)=C8 tensor C_f, define + + D_P = [ I-P P C ], Q_S=diag(S,C S C). + [ C P I-C P C ] + +Block multiplication gives Q_S D_Q Q_S^-1=D_P. Kronecker multiplication and +C_f^2=I give the same identity for every f. The source's rank4 job becomes +rank4f with identity spectators; it is not a rank8f job. These equalities are +linear coordinate permutations after valid reduction to the source local +ring; equality of the coordinate maps implies equality on arbitrary input +functions. No inference from a few special Boolean data inputs is needed. + +Let a parent request be D_(gPg^-1) on the complete cover row g, and the child +canonical target be D_(hQh^-1). Push the parent's whole role fiber to h=gS, +execute the complete child and return by S^-1. Then + + (gS) Q (gS)^-1 = g P g^-1. + +Right multiplication by the invertible fixed S is a bijection of the entire +GL cover, so no arbitrary input is discarded/copied or assumed zero. Source +'gather' notation can list S^-1 for the input address lookup; our statement +uses the explicit push convention above. Both routes remain paid. + +At f1/f2, small witnesses modulo25 and49 compare the canonical routed physical +operator, applied to every linear coordinate basis vector, with a separately +implemented direct projector action. There are384 such basis-column checks. +These small rings do not replace the actual q>2^45 N^5 rule. The proof is over +the rational identities and valid local-ring reductions at every width. + +## 3. Weights, complete cover rows and real carries + +The parent's external unit weight may depend on exposed ancestor coordinates +and column index but is independent of the current fresh cover row/roles. +Its address map Lambda=diag(A,I) therefore commutes with the fiber route: +the route changes g only and Lambda has the same value before/after it. This +is an equality of two maps on the product domain, not a claim that arbitrary +matrix S commutes with a diagonal matrix A on one ARRAY. Conjugating the +whole routed word gives the requested weighted projector endpoint. + +A leaf weight can depend on the current OUTER g because that g is a spectator +ancestor of the INNER call. It must remain independent of the inner fresh row. +An inner ordinary call receives all outer row/head/type fields as complete +spectators; its own stock is disjoint. This is exactly the completed type in +P1/P2, not a heterogeneous-weight supplier assumption. The finite control uses +a nonzero address and two actual row representatives to show that a weight +illegally reading the fresh row produces unequal route/weight composites. + +Write g=g0+qG1. For a fixed rational matcher reduced modulo q^w, let +h0=(g0 S) mod q. The high-coordinate map is + + G1 -> G1 S + (g0 S-h0)/q (mod q^(w-1)). + +For each finite low type g0, every entry of G1 ranges independently over the +complete local ring; invertibility depends only on g0. Thus ordinary chunk +operations see complete ranges and all other high entries as spectators. +The carry is determined by the fixed low type and source matcher and is +charged. The code separately reconstructs this formula at w2 with nonzero +high matrix and rejects dropping its actual carry. A finite low-type +permutation is also paid; it is not an unpriced gather. + +For this S, deterministic rational elimination yields5 swaps,5 unit scalings +and14 shears, and reconstructs S in the exact chronological right-product +order. On the8-row high matrix, ONE route consequently uses40 ordinary chunk +interchanges,40 fixed unit scalings,112 linear ordered shifts and at most64 +carry shifts, plus one finite low-type permutation. Its inverse has the same +conservative counts. The PAIR ledger is80 ordinary interchanges,80 scalings, +224 linear shifts, at most128 carry shifts and2 low-type permutations. +The tensor multiplicity f does not enlarge the8-dimensional cover row. +An embedding into a fixed larger compiler N gives a finite constructive count +by the same elimination and high-row algorithm. The count depends on that +fixed program; it is not assumed uniformly constant as N changes. + +Each ordinary interchange uses the completed backend with the other high +coordinates/low type as spectators. The ordered-affine/unit-scaling primitive +cost remains inherited P2, explicitly charged. The finite low-type permutation +can be generated by a finite table/cycle decomposition, whose size is bounded +by |GL_N(F_q)|; its source physical routing implementation is retained. We +have not executed the astronomical compiled routing list or independently +proved P2's tape realization. Their charges remain finite algorithm-derived +constants, never zero. + +## 4. Weighted atoms consume exactly the available completed API + +For every unit a in a commutative source local ring, let + + J1=[0 1;1 0], L(b)=[1 0;b 1], U(a)=[1 a;0 1]. + +The exact identities are U(a)=J1 L(a) J1 and + + Ja=diag(1,-1) U(a) L(-a^-1) U(a)=[0 a;a^-1 0]. + +Consequently the chronological literal word uses4 OLD ordinary J1 calls, +3 prefix-controlled shifts and1 fixed sign. It requires no weighted backend +primitive. Every J1 exchanges two complete atom chunks with all descriptor/ +ancestor/ROW fields as spectators. Unequal inner prime is handled at the +completed ordinary endpoint, as below. The code checks this exact word over +rational units2 and3 and rejects deleting an actual J1. It does not replace +Ja by an oracle or assume differently weighted internal jobs can mix. + +## 5. Completed ordinary body and two ROW levels + +For any module of chunk coordinates and any reversal involution C, assume a +completed raw body F_n(H,D)=(C D,C H) preserves its external ROW/spectators. +Trace the actual chronological source wrapper: + + D-=H; F_n; D+=H; F_n; D=H-D. + +Starting at arbitrary H,D its states are +(H,D-H), (C(D-H),C H), (C(D-H),C D), (D,D-H), (D,H). +External fields are unchanged at every raw-call return. Three additive maps +are charged and the two completed F_n calls reuse the same restored reserve. +Their fixed multiplicity is outside the stopped recurrence, not a factor +inserted into every characteristic-moment branch. + +Borrowing is also explicit. Split the original complete argument chunks as +H=(H_hi,H_body), D=(D_hi,D_body). Reinterpret H_hi as the preceding ROW for +the ordinary body call; D_hi and original intervening Z remain spectators. +After the completed body the state is + + H_hi, D_body, Z, D_hi, H_body. + +Restore/unpad the ROW before the completed high-part interchange, then swap +H_hi,D_hi with the bodies/Z as spectators. The exact result is D,Z,H. The +borrowed high data was arbitrary original data; it was neither initialized +nor discarded. With k=ceil(log_q S(e,w))=O(w log e), k=S. Those constants +multiply only finitely in three named levels, not once per coarse recursion +node. The completed genuine-rectangle invariant permits unpadding at each +return boundary. Every initialization, retention and removal remains paid. + +The small witnesses use q5/q7,w2, padding25 to32 and49 to64, giving paired +volume ratios1024/625 and4096/2401, each<4. A row divisor3 pads the row ranges +to27 and51, charging2 owned added rows in each case. These are type fixtures, +not actual large-q compiler executions or practical stock thresholds. Replacing +the completed endpoint by the ACTUAL raw reversed binary body maps the genuine +rectangle out of itself; the rejection is not a synthetic malformed padding +label. This provides a discriminating reason the source's completed boundary +is necessary. + +## 7. Complete first-edge price type and finite chain + +No raw rank/profile changes occur. The inherited4760 caller retains11400 +original owners,57339 paid queries and7848 global helper originals; +its local supplier has436 independent helpers. +All nine paid rank7 COPY episodes per local FULL remain charged. There are +72 partial rank4 output jobs,144 added matcher routes and7548 other raw +nonidentity port routes. Their sum7692 is a RAW route census, not the count +after uniform compilation. + +Every fixed compiled matcher pair consumes its paid completed ordinary route, +fixed shifts/scalings/carries and owned movement. Every weighted leaf consumes +4 ordinary atom interchanges. Cover fallback remains paid with the source +2N^3/q fraction and up to32N^2 bad children, under the new fixed large-prime +budget. Target completion and splitting are unchanged. No new productive +credit is introduced by padding, ROW or copies. + +Set b0=.0034597,rho=.01,C1=.00347545805-(2^-36+10^-20). By P1-P3, after fixing +all new finite constants, the three root costs have the source form + + O(V[e^(1-rho) + +e^((1-rho)(1-C1)+rho(1-b0)) + +e^rho log e]). + +The middle exponent is1-a1 for a1=(1-rho)C1+rho b0. Actual computed rational +gaps establish b02^45 N^5, a compiler-size test or a stock threshold. +- Seven independent boundary controls reject an omitted matcher, omitted column + tail reversal, fresh-ROW-dependent weight, inner ROW alias, missing weighted + leaf swap, premature unpadding after the actual raw reversed body and dropped + high-matrix carry. Comparisons use coordinate actions or returned states; + they do not merely compare two copies of the asserted equality. + +The finite code corroborates the generic proof. It does not infer universal +arbitrary-input correctness solely from those22 cases. No full658/11400 RAW +native replay or astronomical compiled program was executed. + +## Complete cost boundary + +All4760 ranks remain unchanged:11400 original owners,57339 paid queries, +7848 helper originals, all nine rank7 COPY charges per local FULL retained. +The144 added partial-helper matching routes and7548 inherited port routes +remain paid; their raw total7692 is not a final compiled count. + +For the selected coarse8-dimensional matcher pair, explicit high-matrix +routing uses80 completed ordinary chunk interchanges,80 fixed unit scalings, +224 linear ordered shifts, at most128 carry shifts and2 finite low-type +permutations. Each is charged by the source fixed-rational routing primitive; +the two low-type permutations and their finite table/cycle costs remain +separate. This is a conservative constructive bound, not a practical tape +constant or a reduction of the inherited route count. For a fixed larger +compiled N, the same finite elimination/high-row algorithm gives its new +N-dependent constant before argument width varies. + +Every weighted atom uses4 completed ordinary swaps,3 controlled shifts and +1 fixed sign. Every completed ordinary body uses2 completed raw bodies and +3 additions; high-part exchange, row/radix padding, stock initialization and +removal, owned erasure, completion/splitting and full bad-class fallback remain +charged. Positive existing adapter/stock/relaxation gaps absorb fixed +constructively bounded constants, not an unknown asymptotic operation. + +Given the retained primitive bounds, the first-edge root costs remain + + O(V[e^.99 + e^(.99(1-C1)+.01(1-.0034597)) + e^.01 log e]), + +where C1=.00347545805-(2^-36+10^-20). The written proof then freezes each +backend before the next and obtains the existing finite3-level induction. +Exact Fraction checks reproduce the already declared stage gaps; no new +exponent is extracted. This validates the composition's type/cost implication +inside its conditional model, not a complete ordinary supplier implementation. + +## What still blocks full independent admission + +The actual finite native/compiler program's ROW restoration and distinct +physical allocation at all widths, the source ordered-affine/scaling/tape +implementation, generated precision/machine constants and analytic/outer +recovery remain inherited. They are explicitly P1-P3 in PROOF.md. The code +sets full4814_primitive_API_independently_proved=False. If an unconditional or +complete physical API audit is desired, it needs a literal source-bound +N-dimensional physical stock/role/route generator satisfying those premises. +Another root evaluation or this local fixture cannot supply it. + +The current positive result can strengthen the justification that4814's +conditional ordinary.003475458 uses no stronger completed interface than its +retained source allows. It cannot independently promote that record from an +archival/partially-reviewed status, prove the underlying BIT machine or raise +the global bound while the complex supplier binds. Separate4940 work remains +primary. Independent review is required before the root treats this finding +as accepted; this packet contains author checks only until that review lands. + +## Reproduction and source/credit + +Read-only from the worktree root: + + python3 -I -B outputs/bit-completed-backend-api-gate/implementation/check.py + python3 -I -O -B outputs/bit-completed-backend-api-gate/implementation/check.py + +Explicit --write writes only RESULT.json and implementation/SOURCES.json. +The script fetches immutable source Git objects; no network, primary checker +import or shared source write is performed. Normal/O stdout must match. +The formal typed inner raw contract in the fixtures is clearly labelled; +it is not a disguised claim to execute the actual full compiler. + +Credit ai-nanachi4760/4814/4326; rohanarun185/199 and Maxime Fleury204; +Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612, +and the retained whole-job/ROW/native/precision/tape/outer lineage. New4944 +(physically typed CRT placement) and4942 (that callee's branch threshold) +are neighboring source-bound uses, not this completed-backend proof; their +CRT layouts and threshold calculations are not repeated. Substantial OpenAI +Codex assistance, Apache-2.0. No human or proof-kernel review is claimed. diff --git a/research/bit-completed-backend-api/independent/frozen/RESULT.json b/research/bit-completed-backend-api/independent/frozen/RESULT.json new file mode 100644 index 0000000000..5136721f4a --- /dev/null +++ b/research/bit-completed-backend-api/independent/frozen/RESULT.json @@ -0,0 +1,2498 @@ +{ + "all_width_proof": "See PROOF.md; finite fixtures are corroboration only", + "arbitrary_data_scope": "Exact coordinate operator identities + written universal permutation/interface proof; no full arrays or astronomical template executed", + "column_multiplicities": [ + 1, + 2 + ], + "controls": { + "fresh_ROW_weight": true, + "inner_ROW_alias": true, + "omit_column_tail_reversal": true, + "omit_high_matrix_carry": true, + "omit_matcher": true, + "omit_weighted_leaf_swap": true, + "premature_padding_cleanup": true + }, + "finite_levels": [ + { + "adapter_gap": "4276027093749855738909939/655360000000000000000000000", + "admitted": "8688251/2500000000", + "backend": "34597/10000000", + "exact": "2277572906250144261090061/655360000000000000000000000", + "relaxation_gap": "36106144261090061/655360000000000000000000000", + "stock_gap": "646528827093749855738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275924854968415738909939/655360000000000000000000000", + "admitted": "8688641/2500000000", + "backend": "8688251/2500000000", + "exact": "2277675145031584261090061/655360000000000000000000000", + "relaxation_gap": "38727584261090061/655360000000000000000000000", + "stock_gap": "646528724854968415738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275923832606815738909939/655360000000000000000000000", + "admitted": "1737729/500000000", + "backend": "8688641/2500000000", + "exact": "2277676167393184261090061/655360000000000000000000000", + "relaxation_gap": "12513184261090061/655360000000000000000000000", + "stock_gap": "646528723832606815738909939/655360000000000000000000000" + } + ], + "fixture_cap": 64, + "fixtures": [ + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + } + ], + "full4814_primitive_API_independently_proved": false, + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "native_rawbody_ROW_semantics": "Inherited premise; wrapper proof checks its exact use, not actual full compiler implementation", + "new_kappa": false, + "original_helper": 462, + "padding_fixtures": [ + { + "binary_range": 32, + "digit_width": 2, + "owned_padded_rows": 2, + "padded_row_range": 27, + "radix": 5, + "range": 25, + "row_divisor": 3, + "two_range_volume_factor": "1024/625" + }, + { + "binary_range": 64, + "digit_width": 2, + "owned_padded_rows": 2, + "padded_row_range": 51, + "radix": 7, + "range": 49, + "row_divisor": 3, + "two_range_volume_factor": "4096/2401" + } + ], + "physical_basis_columns_checked": 384, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "right_route_elimination_counts": { + "add": 14, + "scale": 5, + "swap": 5 + }, + "right_route_factors": [ + [ + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "2", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + ], + "routing_cost_primitive": "Inherited fixed-rational ordered-affine/scaling/shift lemma; every elementary factor is charged", + "selected_record_changed": false, + "selected_route_pair_high_matrix_ledger": { + "carry_ordered_shifts_upper": 128, + "fixed_unit_scalings": 80, + "linear_ordered_shifts": 224, + "low_type_permutations": 2, + "ordinary_chunk_interchanges": 80, + "scope": "N=8 coarse head; all charged; low-type finite-permutation costs separate; tensor f does not enlarge cover row dimension" + }, + "small_fixtures": 22, + "source_frame": 506, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "status": "PASS_ONE_CONDITIONAL_A0_TO_A1_API_IMPLICATION_NOT_PRIMITIVE_ADMISSION", + "weighted_leaf_fixtures": [ + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 3 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 3 + } + ] +} diff --git a/research/bit-completed-backend-api/independent/frozen/SOURCES.json b/research/bit-completed-backend-api/independent/frozen/SOURCES.json new file mode 100644 index 0000000000..d1904f7c89 --- /dev/null +++ b/research/bit-completed-backend-api/independent/frozen/SOURCES.json @@ -0,0 +1,15 @@ +{ + "checker_sha256": "1cd0967b2149a286f440efe6e7249ff1bdd32b0b8413036e6767dc30bc13d4b7", + "files": { + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "research/bit-finite-ordinary-bootstrap/PROOF.md": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "research/bit-finite-ordinary-bootstrap/RECORD.json": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "research/bit-finite-ordinary-bootstrap/independent.py": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "schema_version": 1, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747" +} diff --git a/research/bit-completed-backend-api/independent/frozen/check.py b/research/bit-completed-backend-api/independent/frozen/check.py new file mode 100644 index 0000000000..c1f1a653fb --- /dev/null +++ b/research/bit-completed-backend-api/independent/frozen/check.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 +"""One source-bound conditional completed ordinary backend API gate. +No predecessor executable/price engine imported. Apache-2.0; Codex assistance. +""" +from pathlib import Path +from fractions import Fraction as F +from hashlib import sha256 +from collections import Counter +import json,subprocess,sys +HERE=Path(__file__).resolve().parent +PIN='f56ae4533a7d97d782a2c596a33fe844cd051747' +PATHS={'frames':'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json','word':'research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz','proof':'research/bit-finite-ordinary-bootstrap/PROOF.md','independent':'research/bit-finite-ordinary-bootstrap/independent.py','bridge':'research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md','bit':'notes/three-stage-cover-bit.tex','rows':'notes/three-stage-cover-rows.tex','record':'research/bit-finite-ordinary-bootstrap/RECORD.json'} +def need(x,m): + if not x:raise ValueError(m) +def eye(n):return [[F(i==j)for j in range(n)]for i in range(n)] +def tr(a):return list(map(list,zip(*a))) +def mm(a,b):return [[sum((x*y for x,y in zip(r,c)),F(0))for c in zip(*b)]for r in a] +def add(a,b,k=1):return [[x+k*y for x,y in zip(r,s)]for r,s in zip(a,b)] +def inverse(a): + n=len(a);w=[list(r)+e for r,e in zip(a,eye(n))] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]);w[j],w[k]=w[k],w[j];v=w[j][j];w[j]=[x/v for x in w[j]] + for i in range(n): + if i!=j: + z=w[i][j];w[i]=[x-z*y for x,y in zip(w[i],w[j])] + return [r[n:]for r in w] +def kron(a,f):return [[a[i//f][j//f]*F(i%f==j%f)for j in range(len(a[0])*f)]for i in range(len(a)*f)] +def paired(p): + n=len(p);c=[[F(i+j==n-1)for j in range(n)]for i in range(n)];u=add(eye(n),p,-1) + return [x+y for x,y in zip(u,mm(p,c))]+[x+y for x,y in zip(mm(c,p),mm(mm(c,u),c))] +def paired_map(s): + n=len(s);z=[[F(0)]*n for _ in range(n)];c=[[F(i+j==n-1)for j in range(n)]for i in range(n)] + return [x+y for x,y in zip(s,z)]+[x+y for x,y in zip(z,mm(mm(c,s),c))] +def mod(a,m):return [[(x.numerator*pow(x.denominator,-1,m))%m for x in r]for r in a] +def mv(a,v,m):return [sum(x*y for x,y in zip(r,v))%m for r in a] +def direct_action(p,v,m): + # Independently apply the actual projector law coordinate-by-coordinate. + n=len(p);h,t=v[:n],v[n:];ph=mv(p,h,m);pct=mv(p,list(reversed(t)),m) + return [(h[i]-ph[i]+pct[i])%m for i in range(n)]+[(t[i]+ph[n-1-i]-pct[n-1-i])%m for i in range(n)] +def decompose(s): + w=[r[:]for r in s];n=len(s);ops=[] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]) + if k!=j:w[j],w[k]=w[k],w[j];ops.append(('swap',j,k,F(1))) + v=w[j][j] + if v!=1:w[j]=[x/v for x in w[j]];ops.append(('scale',j,j,1/v)) + for i in range(n): + if i!=j and w[i][j]: + z=-w[i][j];w[i]=[x+z*y for x,y in zip(w[i],w[j])];ops.append(('add',i,j,z)) + need(w==eye(n),'deterministic rational elimination') + factors=[] + for typ,i,j,z in ops: + e=eye(n) + if typ=='swap':e[i],e[j]=e[j],e[i] + elif typ=='scale':e[i][i]=1/z + else:e[i][j]=-z + factors.append(e) + out=eye(n) + for e in factors:out=mm(out,e) + need(out==s,'literal right multiplier factor order') + return ops,factors + +def wrapper(h,d,rows,raw): + # Source exact completed ordinary body; rows are read-only spectators of raw. + h=list(h);d=[y-x for x,y in zip(h,d)];h,d,r=raw(h,d,rows) + d=[x+y for x,y in zip(d,h)];h,d,r=raw(h,d,r) + d=[x-y for x,y in zip(h,d)] + return h,d,r + +def main(): + raw={k:subprocess.check_output(['git','--no-replace-objects','show',PIN+':'+p])for k,p in PATHS.items()} + need(sha256(raw['frames']).hexdigest()=='d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010','actual source frame bank') + import gzip + word=json.loads(gzip.decompress(raw['word']));frame=json.loads(raw['frames'])['frames']['506'] + need(word['start'][462]==0 and word['final'][462]==506 and frame['dim']==4,'actual arbitrary helper462 rank4') + B=[[F(x)for x in r]for r in frame['B']];A=[[F(x)for x in r]for r in frame['A']] + P=mm(mm(tr(B),inverse(mm(B,tr(B)))),B);S=tr(B+A);Si=inverse(S);Q=[[F(i==j and i<4)for j in range(8)]for i in range(8)] + need(mm(P,P)==P and mm(mm(S,Q),Si)==P,'source rational idempotent and matcher') + ops,factors=decompose(S);need(all(x.denominator%5 and x.denominator%7 for r in S+Si+P for x in r),'declared fixture primes valid') + controls={};fixtures=[];basis_columns=0 + for f in (1,2): + Pf,Sf,Qf=kron(P,f),kron(S,f),kron(Q,f);n=8*f;Sfi=inverse(Sf) + need(mm(mm(paired_map(Sf),paired(Qf)),paired_map(Sfi))==paired(Pf),'actual reversed-tail all-f tensor form in fixture') + # This wrong C8 tensor I_f must fail at f2, unless accidentally symmetric. + if f==2: + wrong=[[F(i//f+j//f==7 and i%f==j%f)for j in range(n)]for i in range(n)] + need(wrong!=[[F(i+j==n-1)for j in range(n)]for i in range(n)],'wrong tail reversal distinguished') + controls['omit_column_tail_reversal']=True + for prime in (5,7): + m=prime**2 + for variant in (0,1): + g=eye(8);g[0][1]=F(variant);gi=inverse(g);h=mm(g,S) + gp=mm(mm(g,P),gi);hq=mm(mm(h,Q),inverse(h));need(gp==hq,'whole cover route g to gS correct') + need(mm(h,Si)==g,'exact row inverse return') + # A genuinely independent coordinate path: route via gS,Q then undo vs + # direct requested projector gPg^-1 on every linear coordinate basis. + routed=paired_map(kron(h,f));unroute=paired_map(kron(inverse(h),f));canonical=paired(Qf) + dp=mod(kron(gp,f),m);ri=mod(unroute,m);rc=mod(canonical,m);ro=mod(routed,m) + # Independent q-adic high-matrix route/carry, with fixed nonzero high part. + g0=mod(g,prime);G1=[[0]*8 for _ in range(8)];G1[1][0]=1 + sm=mod(S,m);slow=mod(S,prime) + gw=[[g0[i][j]+prime*G1[i][j]for j in range(8)]for i in range(8)] + direct=mod(mm(gw,sm),m);z=mm(g0,sm) + low=[[int(x)%prime for x in row]for row in z] + carry=[[(int(z[i][j])-low[i][j])//prime%prime for j in range(8)]for i in range(8)] + linear=mod(mm(G1,slow),prime) + high=[[(linear[i][j]+carry[i][j])%prime for j in range(8)]for i in range(8)] + rebuilt=[[low[i][j]+prime*high[i][j]for j in range(8)]for i in range(8)] + need(direct==rebuilt,'actual whole-cover high affine route including carry') + without=[[low[i][j]+prime*linear[i][j]for j in range(8)]for i in range(8)] + need(without!=direct,'omitting real route carry fails') + controls['omit_high_matrix_carry']=True + for ancestor in (0,1): + weights=[1+(i+ancestor)%2 for i in range(n)] + lam=eye(2*n);lami=eye(2*n) + for i,a in enumerate(weights):lam[i][i]=a;lami[i][i]=F(1,a) + lm,li=mod(lam,m),mod(lami,m) + for j in range(2*n): + v=[int(i==j)for i in range(2*n)] + lhs=mv(lm,mv(ro,mv(rc,mv(ri,mv(li,v,m),m),m),m),m) + rhs=mv(lm,direct_action(dp,mv(li,v,m),m),m) + need(lhs==rhs,'independent all-basis weighted physical helper route') + basis_columns+=1 + # Two visible ROW levels + a complete spectator, held by the raw contract. + r={'outer':(prime,variant),'inner':(ancestor,prime+1),'spectator':(3,7,11)} + x=[F(i+1)for i in range(n)];y=[F(2*i-3)for i in range(n)] + rawbody=lambda a,b,row:(list(reversed(b)),list(reversed(a)),dict(row)) + def inner_completed(a,b,row): + # Inner ROW is borrowed from the CURRENT argument's own high part, + # not a new arbitrary owner or externally supplied empty stock. + ah,bh=list(a[:1]),list(b[:1]);ar,br=list(a[1:]),list(b[1:]) + borrowed=dict(row);borrowed['borrowed_inner_ROW']=tuple(ah) + ao,bo,ret=wrapper(ar,br,borrowed,rawbody) + need(ret==borrowed,'inner completed body restores borrowed/current high ROW') + del ret['borrowed_inner_ROW'] + # One completed high-part interchange, after ROW restoration. + return bh+ao,ah+bo,ret + def nested_raw(a,b,row): + aa,bb,ret=inner_completed(a,b,row) + return list(reversed(aa)),list(reversed(bb)),ret + xo,yo,rr=wrapper(x,y,r,nested_raw) + need(xo==y and yo==x and rr==r,'completed wrapper arbitrary typed ROWs') + # The second nesting order is a control: overwrite outer row by inner. + def badbody(a,b,row): + row=dict(row);row['outer']=row['inner'];return list(reversed(b)),list(reversed(a)),row + _,_,bad=wrapper(x,y,r,badbody);need(bad!=r,'unrestored/aliased ROW control') + controls['inner_ROW_alias']=True + fixtures.append({'f':f,'prime':prime,'modulus':m,'g_variant':variant,'ancestor':ancestor,'basis_columns':2*n,'two_ROW_levels_preserved':True,'inner_stock_borrowed_from_argument':True}) + # Non-tautological fresh weight failure: the route changes the row queried + # by the illegal weight. Choose the already declared variant1, no search. + g=eye(8);g[0][1]=1;h=mm(g,S) + fresh=lambda z:1+int(z[0][1]==0) + need(fresh(g)!=fresh(h),'fresh-row weight descriptor changes on actual route') + address=[1]+[0]*15 + left=(tuple(map(tuple,h)),fresh(g)*address[0]) + right=(tuple(map(tuple,h)),fresh(h)*address[0]) + need(left!=right,'actual fresh-row scaling and route commutator on nonzero address') + controls['fresh_ROW_weight']=True + # Four OLD ordinary swaps, three shifts, one fixed sign; exact modular word. + I=eye(2);J=[[F(0),F(1)],[F(1),F(0)]] + def L(a):return [[F(1),F(0)],[F(a),F(1)]] + sig=[[F(1),F(0)],[F(0),F(-1)]];weighted=[] + for prime in (5,7): + m=prime**2 + for a in (2,3): + aa=F(a);word=[J,L(aa),J,L(-1/aa),J,L(aa),J,sig] + op=I + for e in word:op=mm(e,op) + expected=[[F(0),aa],[1/aa,F(0)]] + need(op==expected,'literal4 ordinary weighted leaf swaps') + bad=I + for k,e in enumerate(word): + if k!=0:bad=mm(e,bad) + need(bad!=expected,'omitted ordinary atom interchange') + controls['omit_weighted_leaf_swap']=True;weighted.append({'prime':prime,'unit':a,'ordinary_swaps':4,'shifts':3,'signs':1}) + # Padding uses the invariant genuine rectangle, not an assumed inverse of + # an internally uncompleted body. These address permutations are independent + # of the rational matrix helper checks above. + padding=[] + for radix in (5,7): + original=radix**2;padded=1<<(original-1).bit_length();need(padded<2*original,'two chunk binary pad bound') + genuinely=set((i,j)for i in range(original)for j in range(original));returned={(j,i)for i,j in genuinely} + need(returned==genuinely,'completed ordinary swap preserves genuine rectangle') + need(all((i=row_stock and row_padded<2*source,'owned ROW pad bound') + bits=padded.bit_length()-1 + rev=lambda n:sum(((n>>i)&1)<<(bits-1-i)for i in range(bits)) + bad={(rev(j),rev(i))for i,j in genuinely} + need(bad!=genuinely,'actual raw reversed body violates genuine padding rectangle') + controls['premature_padding_cleanup']=True + padding.append({'radix':radix,'digit_width':2,'range':original,'binary_range':padded,'two_range_volume_factor':str(F(padded**2,original**2)),'row_divisor':row_stock,'padded_row_range':row_padded,'owned_padded_rows':row_padded-source}) + # Reject omitted physical whole-job matcher with actual matrices. + controls['omit_matcher']=paired(Q)!=paired(P) + need(all(controls.values()),'every semantic control distinguishes') + C1=F('.00347545805')-F(1,2**36)-F(1,10**20);rho=F(1,100);b=F('.0034597');levels=[] + for value in (F('.0034753004'),F('.0034754564'),F('.0034754580')): + a=(1-rho)*C1+rho*b;need(b=genuine) + need(rev(x) gS` is a bijection of the *whole* cover fiber, so no input is copied, +discarded, or assumed zero. The child word can mix its roles at a common +child row `h`, because those routed inputs are arbitrary independent data. +After the completed word returns its independent endpoints, undoing the +routes restores the parent ordering. The finite flow's ownership and +chronology are still required; cover routing does not repair an aliased +or cyclic flow. + +## 4. One common external weight survives every internal routing + +At column multiplicity `f`, let the outer invocation's diagonal weight +`A` be any permitted generated descriptor on its `Nf` head atoms. It can +depend on exposed ancestor rows and atom indices. It must be independent +of all fresh role and cover fields of this entire compiled invocation. +Write `Lambda_A=diag(A,I)`. + +Conjugate the entire completed covered word by `Lambda_A`. Pointwise scalar +ADDs commute with this common address permutation across roles. Every +internal role route also commutes with it: a route changes only a fresh +role or the current cover row, while `A` is independent of both. Thus the +matching identity becomes + +\[ +\Lambda_A D_{(gS)Q(gS)^{-1}}\Lambda_A^{-1} +=\Lambda_A D_{gPg^{-1}}\Lambda_A^{-1}. +\] + +There is no child-specific weight to reconcile inside the precompiled +word. The source/complement product gives + +\[ +\Lambda_A D_I\Lambda_A^{-1}=F_A +\] + +on every productive source array. This is exactly the inherited weighted +full-interchange endpoint. Owned zero storage is unaffected by address +permutations and is excluded from productive output credit; its allocation, +initialization and final erasure still belong to the finite word. + +The condition on `A` is essential. The companion audit exhibits a concrete +failure when `A` is allowed to depend on the current fresh cover row. The +argument does not quietly weaken the old ancestor-only contract. + +## 5. Only the final leaves become weighted children + +After the mixed finite compiler has replaced every internal request, suppose +the remaining paid projector requests have rank one. At multiplicity `f`, +each is a rank-`f` residual on the outer atom space. Apply the inherited +generic ordered normal form to this *finished* leaf list. + +For a generic residue class, that proof produces unit lower intrabank and +cross-bank adapters around one contiguous weighted reversed interchange. +For column `j`, the resulting weight is + +\[ +A_{\rm child}[j]=A[i_0f+j]D_P[0], +\] + +with the inherited reversed tail pairing. The pivot coefficient is evaluated +from the current outer cover row and the fixed leaf projector. Those are +ancestor data when the recursive rank-`f` child is invoked. Its fresh roles +come from unused row stock, so the child's weight is independent of them. + +Different leaf calls can have different weights; the ordinary recursion +already permits this. Each such child itself receives one common weight +across all of *its* fresh roles and cover rows. This is the critical +distinction from calling a mixed unit on several already-normalized, +differently weighted parent jobs. + +Bad residue classes use the inherited genuine local-ring fallback, including +its swaps, paired scalings and reversals. This is charged explicitly rather +than declaring a nonunit pivot invertible. + +## 6. Routing is priced by the retained native lemma + +The cover row has the unique chart `g=g0+qG1`, with `g0` in `GL_N(F_q)`. +For each fixed matcher `S`, right multiplication gives a permutation of +the finite low type and a fixed affine map on the high matrix, with carry +determined by the low type. The retained proof of finite cover routing +implements this with a constant number of fixed scalings, ordered shifts +and old atom interchanges. Its cost is + +\[ +O(Vw^{1-a_{\rm old}}) +\] + +per fixed route. It is not a free address-gather operation. A precompiled +word contains finitely many matchers, so their total remains a finite +constant times this term. High matrices are streamed by fixed low type; +the number of tapes and program types does not grow with `w`. + +The same statement holds for nonintegral rational matchers: choose `q` +avoiding their fixed denominators, use their local-ring representatives, +and apply the retained fixed-rational routing lemma. The exact small audit +uses integral unimodular matchers to exercise the carry formula directly. + +## 7. Moment and row-stock consequences + +Let the finite uniform compiler have `B` productive source arrays, ambient +rank `N`, and `P` rank-one leaves, with a certified strict inequality + +\[ +\frac PB N^{-\tau}<1. +\] + +The covered, weighted word has the same normalized good-class leaf count. +Choose `q` large enough that the full fallback surcharge fits the displayed +slack. For example, the conservative inherited per-leaf bounds yield + +\[ +\mu_\tau\le +\frac PB N^{-\tau} +\left(1+\frac{2N^3}{q}\,32N^2\right)<1. +\] + +No old fixed choice of `q` or old numerical fallback envelope is reused for +the potentially enormous new `N`. Prime avoidance and a sufficiently large +prime exist because the whole precompiled program is finite. + +For the present candidate, use the exact mixed saving +`C0=69/25000=0.00276` for the finite compiler and retain +`C1=11/4000=0.00275` after covering. Put `d=C0-C1=1/100000`. +The former gives `P/B\frac{256N^5}{d}=25,600,000N^5. +\] + +Then the fallback multiplier is less than `1+d/4`, while +`N^d >= 1+d/2` for `N>=2`, using `log 2>1/2` and `exp x>=1+x`. +Thus the complete moment is strictly below +`(1+d/4)/(1+d/2)<1`. This uses an explicit exponent gap and does not +require knowing the eventual winning template's numerical moment slack. + +The cover consumes `N^2(w-1)` high-row digits plus a fixed low-type and role +reserve. Its finite owned-storage and scalar costs may be enormous. They +replace the old constants. For fixed `N` and a fixed finite word, the +ancestor reserve remains `O(w log e)`, and the previous eventual-threshold +arguments still apply after substituting those constants. They cannot be +reused numerically without that substitution. + +The existing weighted recursion can now be applied to this one uniform +supplier: every paid query has width at most `f`, the endpoint is `F_A`, and +all routing and scalar terms have the inherited permitted form. This is a +native-interface bridge. The complete final exponent still depends on the +mixed compiler's termination theorem, its exact leaf-count saving, and the +outer multiplication transfer. + +## 8. The ordinary BIT saving and explicit template constants + +The retained stopped recurrence gives + +\[ +T(n,w)=O(n+n^{1-C_1}w^{1-a_{\rm old}}),\qquad +a_{\rm old}=384599/10^{10}. +\] + +The old atom exponent `1/1000` cannot be reused here: its linear `n` term +would limit the ordinary saving to `0.001`. Instead choose +`delta=3/1000` and `w=ceil(e^delta)` from the original chunk width `e`. +For the whole compiled program set + +\[ +W(w)=B|\operatorname{GL}_N(\mathbb F_q)|q^{N^2(w-1)}. +\] + +A safe reserve is `W(w)^D * S_old`, with +`D >= floor(log_N ceil(e/w))`; all final ordinary children have rank at +most `floor(n/N)`. Therefore the borrowed high-digit count satisfies + +\[ +k\le D\left(N^2(w-1)+ +\left\lceil\log_q(B|\operatorname{GL}_N(\mathbb F_q)|)\right\rceil\right) ++\left\lceil\log_qS_{\rm old}\right\rceil+1 +=O_{N,B,q}(w\log e). +\] + +This is `o(e)`. For sufficiently large `e`, borrow `ka_BIT` and `delta<1-a_BIT` hold strictly. The linear adapter +term and the borrowed-stock logarithm are lower order. One may relax the +ordinary saving to the simpler rational `27/10000=0.0027`. +`BIT-ALLSIZE-PARAMETERS.json` records all strict rational gaps and the +exact mixed margin at `C0`. This remains conditional on the finite uniform +compiler premise; the enormous word is not materialized in this package. + +The final ambient dimension is `N`, the productive role count is `B`, and +the rank-one leaf count is `P`. They are not the old `64`, `661`, `3739`, +or the base unit's literal counts. Let `C` be the total allocated owned +array fields, `L` the literal scalar/copy/erase count, and `R` all fixed +right routes including inverses. Keep the full finite matrix and +coefficient-height list. The new fixed tape inventory can use one stream +per productive or owned role, with the inherited parking stack; it is +finite in `B+C`. Every route is charged, and every final leaf has its own +normalization and possible fallback. A rank-one generic normalizer and +its inverse use at most `4N^2-2N` elementary lower/cross-bank shears; the inherited bad +normalizer uses at most `32N^2` recursive calls of width at most `f`. + +These constants can be enormous and affect the eventual threshold. Their +dependence on the fixed compiled template does not introduce a new power +of the later input length. The mixed-flow argument is used to bound the +normalized number of paid rank-one leaves; it must not assume that dense +matrix routing costs stay uniformly bounded while the candidate template +dimension `N` is increased in the existence search. + +## 9. Exact finite audit + +Run: + +```sh +python3 -B research/kappa-rebuild/bit/delayed_cover_bridge.py +``` + +The audit enumerates every one of the 3,888 rows of `GL_2(Z/9Z)` for each +of two independently matched target roles. It checks 7,776 exact physical +projector identities, both full cover bijections, the affine high-row carry +formula, and every one of the 6,561 addresses for common-gauge scalar +commutation. Its external weight is `(2,4)`, so it is not restricted to an +unweighted or constant-across-axis input. The emitted leaf-weight histogram +is nonconstant. Two explicit negative controls reject omitting a matcher +and allowing the external weight to depend on the fresh cover row. + +These are independent checks of concrete algebra and a genuine local ring. +The general argument is the conjugacy calculation above, not an inference +from the finite sample. + +## Open next questions + +1. Independently audit that the finite lockstep compiler only substitutes + whole arbitrary-input jobs and gives each simultaneously live child role + a distinct physical array. The row matching here assumes that ownership. +2. Bind the new BIT p3 native physical projector list and its exact local + primitive into the abstract finite compiler, including all COPY centers. +3. Write the parameter substitutions for the eventual row reserve and the + final BIT/complex outer exponent. A finite numerical mixed moment alone + is still insufficient for a new multiplication claim. diff --git a/research/bit-completed-backend-api/independent/inputs/PROOF.md b/research/bit-completed-backend-api/independent/inputs/PROOF.md new file mode 100644 index 0000000000..7db6805f8a --- /dev/null +++ b/research/bit-completed-backend-api/independent/inputs/PROOF.md @@ -0,0 +1,90 @@ +# Finite ordinary backend replacement on the productive BIT supplier + +Scope. This is a conditional composition of the completed ordinary BIT +contracts retained by PR4760 and its source. The raw local/global WORD, its +11400 independent originals, all helper jobs, projector routes and raw mixed +moment are unchanged. The new claim is ordinary BIT b=1737729/500000000. +The complex supplier and selected whole multiplication kappa are unchanged. + +Attribution. Finite acyclic ordinary-leaf bootstrapping and its nested row +restoration argument are prior work: rohanarun's PR185, followed by PR199 and +PR204. Their exact historical heads are identified in SOURCES.json and linked in README.md. +They are not claimed as merged or as a new theorem here. We rederive the +composition on the current productive/delayed-cover contract instead of +reusing their historical numerical constants, tapes or acceptance arithmetic. + +1. Fixed uniform program and paid cover. +On the unchanged PR4760 native invoice, new exact tail verification at tested +saving0.00347545806 and alpha_gap=2^-39 supplies C0=0.00347545805, +H0=377228190883840, H1=262208150916063859466241 and N=2^H1, under its existing +finite compiler and implementation premises. Set d=2^-36+10^-20 and C1=C0-d. +Choose one fixed odd q>2^45*N^5 avoiding all denominators, determinants and +rank witnesses of this completed finite program. Since 2^45*d>256, its full +bad-class multiplier is below 1+d/4, whereas N^d>=1+d/2. Thus the cover +retains the claimed strict moment. Regenerate all q-dependent route, stock, +precision, semantic-height and machine constants. They may be enormous. +No old 21-bit/raw1e9/tape threshold is reused as a bound for this new program. + +2. Backend interface and order of quantifiers. +A_0 is the already completed ordinary BIT supplier of PR4760 with saving +b0=0.0034597. It operates on arbitrary widths and complete chunks, keeps all +preceding/intervening complete spectators, and internally borrows and returns +its row stock. These completed-interface conclusions retain the same source +analytic/native/compiler/tape assumptions; a scalar exponent alone is not +enough. Weighted leaves use four unweighted ordinary atom interchanges, so +this completed A_0 has the required type. Fixed radix ranges are numerically +padded to binary ranges and unpadded at completed endpoints, with volume +factor below four. The backend's internal prime need not equal the outer q. + +For j=1,2,3 define a distinct finite algorithm A_j. Use the fixed uniform +supplier above, w=ceil(e^(1/100)), and only the already frozen A_(j-1) for +ordinary atom, routing and high-part exchanges. Freeze its new constants and +eventual threshold before varying e. Coarse recursive calls decrease atom +count; backend calls decrease j. There is no forward/self-reference and no +depth tending to infinity with the input size. + +3. Costs and separators. +Put rho=1/100. The three retained root costs of A_j are + O(V[e^(1-rho) + + e^((1-rho)*(1-C1)+rho*(1-b_(j-1))) + + e^rho*log(e)]). +Thus a_j=(1-rho)*C1+rho*b_(j-1). On the1e-10 grid choose + b1=0.0034753004, + b2=0.0034754564, + b3=0.0034754580. +Exact rational checks give, at each j, + b_(j-1)0. +Completion at18^1024 and splitting at17^1024 remain fully charged. +The integer compiler uses z=1-C0, z0=(t+z)/2, h=1/64; +H0*h*(z0-t)>=(z0-t)*(5+8*h)*1024+1+8*1024*(1-z0), +and H1*(z-z0)>H0*(1-z0). Old H0/H1 fail these new inequalities. diff --git a/research/bit-completed-backend-api/independent/inputs/RECORD.json b/research/bit-completed-backend-api/independent/inputs/RECORD.json new file mode 100644 index 0000000000..3c8934f23e --- /dev/null +++ b/research/bit-completed-backend-api/independent/inputs/RECORD.json @@ -0,0 +1,72 @@ +{ + "schema": 1, + "status": "PROPOSED_CONDITIONAL_ORDINARY_BIT_003475458", + "scientific_base": "624de9dc66858af0945e5f8a0942488d62280d43", + "axis": "ordinary_BIT_saving", + "admitted": "1737729/500000000", + "ordinary_exact_last_level": "2277676167393184261090061/655360000000000000000000000", + "levels": [ + { + "level": 1, + "backend": "34597/10000000", + "exact": "2277572906250144261090061/655360000000000000000000000", + "admitted": "8688251/2500000000" + }, + { + "level": 2, + "backend": "8688251/2500000000", + "exact": "2277675145031584261090061/655360000000000000000000000", + "admitted": "8688641/2500000000" + }, + { + "level": 3, + "backend": "8688641/2500000000", + "exact": "2277676167393184261090061/655360000000000000000000000", + "admitted": "1737729/500000000" + } + ], + "previous_exact_ordinary": "17713901828029/5120000000000000", + "relative_gain_over_previous_exact": "80443131971/17713901828029", + "raw_moment_word_changed": false, + "raw_crossing_interval": [ + "0.003475458064076428997514", + "0.003475458064076428997515" + ], + "selected_global_kappa_changed": false, + "selected_global_kappa_at_base": "60403/20000000", + "complex_supplier_changed": false, + "maintainer_mathematical_review": "Pending", + "external_independent_reproduction": "Not claimed; separate internal AI source-type and arithmetic audits.", + "hosted_CI": { + "observed_at_utc": "2026-10-22T21:15:30.134364+00:00", + "head": "4a4418d1f274da5dbac8778f0fdf6907a9828594", + "checks": [ + { + "name": "replay (research/bit-finite-ordinary-bootstrap) / replay (research/bit-finite-ordinary-bootstrap)", + "status": "completed", + "conclusion": "success", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39853042928/job/120085718020" + }, + { + "name": "plan", + "status": "completed", + "conclusion": "success", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/39853042928/job/120083966537" + } + ], + "scope": "Linux hosted replay at the stated head; author-submitted CI is not independent mathematical approval." + }, + "publication": { + "PR": 4814, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4814", + "created_at": "2026-10-22T20:36:53Z", + "initial_posted_head": "acac896e0599bf0c0c3be09345247c5213aa686a", + "scientific_commit": "db3856719bdf2b913f9662ec348e39c2c7c65242", + "cadence_rule": "Only actual PR creation counts as a new submission; added commits/body edits do not." + }, + "portability_correction": { + "failed_head": "709fcb31cc66bd8ce2165d60f495259502325536", + "corrected_head": "4a4418d1f274da5dbac8778f0fdf6907a9828594", + "cause": "Four source-pin keys used Windows separators. POSIX repository-relative keys now match across operating systems; all nonpath certificate fields and source hashes are identical." + } +} diff --git a/research/bit-completed-backend-api/independent/inputs/WORD.json.gz b/research/bit-completed-backend-api/independent/inputs/WORD.json.gz new file mode 100644 index 0000000000..776ddd13d6 Binary files /dev/null and b/research/bit-completed-backend-api/independent/inputs/WORD.json.gz differ diff --git a/research/bit-completed-backend-api/independent/inputs/frames.json b/research/bit-completed-backend-api/independent/inputs/frames.json new file mode 100644 index 0000000000..a9a932b926 --- /dev/null +++ b/research/bit-completed-backend-api/independent/inputs/frames.json @@ -0,0 +1 @@ +{"frames":{"0":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[],"dim":0},"1":{"A":[],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":8},"10":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1]],"dim":1},"100":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,0,1,0,-1,0,1]],"dim":1},"101":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,0,1,0,-1,0,-1]],"dim":1},"102":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,0,-1,0,1,0,1]],"dim":1},"103":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,0,-1,0,1,0,-1]],"dim":1},"104":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,0,-1,0,-1,0,1]],"dim":1},"105":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,1,1,0]],"dim":1},"106":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,1,-1,0]],"dim":1},"107":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,-1,1,0]],"dim":1},"108":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,-1,-1,0]],"dim":1},"109":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,0,1,1,0]],"dim":1},"11":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,-1]],"dim":1},"110":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,0,1,-1,0]],"dim":1},"111":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,0,-1,1,0]],"dim":1},"112":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,0,-1,-1,0]],"dim":1},"113":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0]],"dim":2},"114":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1]],"dim":2},"115":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,0,0,0,0,0,1]],"B":[[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1]],"dim":2},"116":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,-1,1,0,0],[0,-1,0,0,1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,1,0,0,1,1,0],[0,0,0,0,1,1,-1,-1]],"dim":2},"117":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,1,0,0],[0,-1,0,0,-1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,1,0,0,1,1,0],[0,0,0,0,1,-1,1,-1]],"dim":2},"118":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,1,1,-1,-1],[0,0,0,0,1,-1,1,-1]],"dim":2},"119":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,1,0,0,1,-1,0],[0,1,1,0,0,-1,1,0]],"dim":2},"12":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1]],"dim":1},"120":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,-1,1,0,0],[0,1,0,0,-1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,1,0,0,1,-1,0],[0,0,0,0,1,1,1,-1]],"dim":2},"121":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,1,0,0],[0,1,0,0,1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,1,0,0,1,-1,0],[0,0,0,0,1,-1,-1,-1]],"dim":2},"122":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,-1,1,0,0],[0,-1,0,0,-1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,1,0,0,-1,1,0],[0,0,0,0,1,1,1,-1]],"dim":2},"123":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,1,0,0],[0,-1,0,0,1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,1,0,0,-1,1,0],[0,0,0,0,1,-1,-1,-1]],"dim":2},"124":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,0,-1,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,1,1,1,-1],[0,0,0,0,1,-1,-1,-1]],"dim":2},"125":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0]],"dim":2},"126":{"A":[[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,1,-1,0,1,0,0,1]],"dim":2},"127":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1]],"dim":2},"128":{"A":[[0,1,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[-1,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,-1,0,0,0,0,0,1]],"B":[[1,-1,1,1,0,0,0,0],[1,0,0,-1,1,0,0,1]],"dim":2},"129":{"A":[[0,1,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,1,0,0,0,0,0,1]],"B":[[1,-1,1,1,0,0,0,0],[1,0,0,-1,-1,0,0,-1]],"dim":2},"13":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,-1,0,1,0,0,1]],"dim":1},"130":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[1,0,0,-1,1,0,0,1],[1,0,0,-1,-1,0,0,-1]],"dim":2},"131":{"A":[[0,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,-1,-1,0,0,0,0],[1,-1,1,-1,0,0,0,0]],"dim":2},"132":{"A":[[0,1,1,0,0,0,0,0],[-1,2,0,1,0,0,0,0],[1,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,-1,0,0,0,0,0,1]],"B":[[1,1,-1,-1,0,0,0,0],[1,0,0,1,-1,0,0,-1]],"dim":2},"133":{"A":[[0,1,1,0,0,0,0,0],[-1,-2,0,1,0,0,0,0],[1,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,1,0,0,0,0,0,1]],"B":[[1,-1,1,-1,0,0,0,0],[1,0,0,1,-1,0,0,-1]],"dim":2},"134":{"A":[[-1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,-2,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1]],"dim":2},"135":{"A":[[0,1,0,0,0,0,0,0],[1,0,-1,1,0,0,0,0],[-2,0,1,0,1,0,0,0],[-1,0,1,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[0,0,1,1,-1,-1,0,0]],"dim":2},"136":{"A":[[-1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[0,1,0,1,0,1,0,1]],"dim":2},"137":{"A":[[-1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,1,-1],[0,0,1,1,-1,-1,0,0]],"dim":2},"138":{"A":[[0,0,1,0,0,0,0,0],[1,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,-1,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[2,-1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,1,-1],[0,1,0,1,0,1,0,1]],"dim":2},"139":{"A":[[1,0,0,0,0,0,0,0],[0,-1,-1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,-1,1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,0,1,1,-1,-1,0,0],[0,1,0,1,0,1,0,1]],"dim":2},"14":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,-1,0,1,0,0,-1]],"dim":1},"140":{"A":[[-1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,-2,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,-1,0,0,0,0,0,1]],"B":[[1,1,0,0,1,1,0,0],[1,0,1,0,0,-1,0,-1]],"dim":2},"141":{"A":[[0,0,1,0,0,0,0,0],[1,-1,0,1,0,0,0,0],[-2,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,1,1,0,0],[0,1,0,1,-1,0,1,0]],"dim":2},"142":{"A":[[-1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,1,0,0,1,1,0,0],[0,0,1,1,0,0,-1,1]],"dim":2},"143":{"A":[[-1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,-1],[0,1,0,1,-1,0,1,0]],"dim":2},"144":{"A":[[0,1,0,0,0,0,0,0],[1,0,-1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,1,0,0,0,1,0],[2,0,-1,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,-1],[0,0,1,1,0,0,-1,1]],"dim":2},"145":{"A":[[1,0,0,0,0,0,0,0],[0,-1,-1,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,1,0,1,-1,0,1,0],[0,0,1,1,0,0,-1,1]],"dim":2},"146":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,-1,1,0,0],[0,-1,0,0,1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,1,-1,0,0,1,1,0],[0,0,0,0,1,1,-1,1]],"dim":2},"147":{"A":[[-2,1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,-1,0,0,0,1,0,0],[1,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,1,1,0],[1,1,1,1,0,0,0,0]],"dim":2},"148":{"A":[[0,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,1,1,0],[1,0,0,-1,1,0,0,-1]],"dim":2},"149":{"A":[[-1,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,-1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,1,-1,1],[1,1,1,1,0,0,0,0]],"dim":2},"15":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,-1,0,-1,0,0,1]],"dim":1},"150":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,-1,1,0,0],[-1,0,0,0,1,0,1,0],[2,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,1,-1,1],[1,0,0,-1,1,0,0,-1]],"dim":2},"151":{"A":[[0,-1,1,0,0,0,0,0],[1,-2,0,1,0,0,0,0],[-1,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,-1,0,0,0,0,0,1]],"B":[[1,1,1,1,0,0,0,0],[1,0,0,-1,1,0,0,-1]],"dim":2},"152":{"A":[[1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,2,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[1,-1,0,0,0,0,1,-1]],"dim":2},"153":{"A":[[0,1,0,0,0,0,0,0],[-1,0,-1,1,0,0,0,0],[-2,0,-1,0,1,0,0,0],[1,0,1,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[0,0,1,1,1,-1,0,0]],"dim":2},"154":{"A":[[1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[0,1,0,1,0,1,0,-1]],"dim":2},"155":{"A":[[1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,1,-1],[0,0,1,1,1,-1,0,0]],"dim":2},"156":{"A":[[0,0,1,0,0,0,0,0],[-1,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,-1,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[2,1,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,1,-1],[0,1,0,1,0,1,0,-1]],"dim":2},"157":{"A":[[1,0,0,0,0,0,0,0],[0,-1,-1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,-1,1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,0,1,1,1,-1,0,0],[0,1,0,1,0,1,0,-1]],"dim":2},"158":{"A":[[1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,-2,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,1,0,0,0,0,0,1]],"B":[[1,-1,0,0,1,-1,0,0],[1,0,-1,0,0,1,0,-1]],"dim":2},"159":{"A":[[0,0,1,0,0,0,0,0],[-1,-1,0,1,0,0,0,0],[-2,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,1,-1,0,0],[0,1,0,1,1,0,-1,0]],"dim":2},"16":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,1,0]],"dim":1},"160":{"A":[[1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,1,0,-1],[0,1,0,1,1,0,-1,0]],"dim":2},"161":{"A":[[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,-1,-1,1],[1,-1,-1,-1,0,0,0,0]],"dim":2},"162":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[-1,0,0,0,1,1,0,0],[-1,0,0,0,1,0,1,0],[2,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,-1,-1,1],[1,0,0,1,1,0,0,-1]],"dim":2},"163":{"A":[[0,-1,1,0,0,0,0,0],[-1,-2,0,1,0,0,0,0],[-1,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,1,0,0,0,0,0,1]],"B":[[1,-1,-1,-1,0,0,0,0],[1,0,0,1,1,0,0,-1]],"dim":2},"164":{"A":[[1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,2,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,1]],"dim":2},"165":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,1,0,0,0,0],[2,0,1,0,1,0,0,0],[-1,0,-1,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[0,0,1,-1,-1,1,0,0]],"dim":2},"166":{"A":[[1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[0,1,0,-1,0,-1,0,1]],"dim":2},"167":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,-1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,1,1],[0,0,1,-1,-1,1,0,0]],"dim":2},"168":{"A":[[0,0,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,1,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[-2,-1,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,1,1],[0,1,0,-1,0,-1,0,1]],"dim":2},"169":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,1,-1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,0,1,-1,-1,1,0,0],[0,1,0,-1,0,-1,0,1]],"dim":2},"17":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,-1,0]],"dim":1},"170":{"A":[[1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,2,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,-1,0,0,0,0,0,1]],"B":[[1,-1,0,0,-1,1,0,0],[1,0,-1,0,0,-1,0,1]],"dim":2},"171":{"A":[[0,0,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[2,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,-1,1,0,0],[0,1,0,-1,-1,0,-1,0]],"dim":2},"172":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,-1,0,0,-1,1,0,0],[0,0,1,-1,0,0,1,1]],"dim":2},"173":{"A":[[1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,-1,0,1],[0,1,0,-1,-1,0,-1,0]],"dim":2},"174":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,-1,0,0,0,1,0],[-2,0,-1,0,0,0,0,1]],"B":[[1,0,-1,0,0,-1,0,1],[0,0,1,-1,0,0,1,1]],"dim":2},"175":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,-1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,1,0,-1,-1,0,-1,0],[0,0,1,-1,0,0,1,1]],"dim":2},"176":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,1,0,0],[0,1,0,0,-1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,1,-1,0,0,-1,-1,0],[0,0,0,0,1,-1,1,1]],"dim":2},"177":{"A":[[2,1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,1,0,0,0,1,0,0],[1,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,-1,-1,0],[1,-1,-1,1,0,0,0,0]],"dim":2},"178":{"A":[[0,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,-1,-1,0],[1,0,0,-1,-1,0,0,1]],"dim":2},"179":{"A":[[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,-1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,-1,1,1],[1,-1,-1,1,0,0,0,0]],"dim":2},"18":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,1,0]],"dim":1},"180":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,1,1,0,0],[-1,0,0,0,-1,0,1,0],[-2,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,-1,1,1],[1,0,0,-1,-1,0,0,1]],"dim":2},"181":{"A":[[0,-1,1,0,0,0,0,0],[1,2,0,1,0,0,0,0],[1,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,-1,0,0,0,0,0,1]],"B":[[1,-1,-1,1,0,0,0,0],[1,0,0,-1,-1,0,0,1]],"dim":2},"182":{"A":[[-1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,-2,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1]],"dim":2},"183":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,1,0,0,0,0],[2,0,-1,0,1,0,0,0],[1,0,-1,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0],[0,0,1,-1,1,1,0,0]],"dim":2},"184":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,-1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,1,1],[0,0,1,-1,1,1,0,0]],"dim":2},"185":{"A":[[-1,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,2,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,1,0,0,0,0,0,1]],"B":[[1,1,0,0,-1,-1,0,0],[1,0,1,0,0,1,0,1]],"dim":2},"186":{"A":[[0,0,1,0,0,0,0,0],[-1,1,0,1,0,0,0,0],[2,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,-1,-1,0,0],[0,1,0,-1,1,0,1,0]],"dim":2},"187":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[1,1,0,0,-1,-1,0,0],[0,0,1,-1,0,0,-1,-1]],"dim":2},"188":{"A":[[-1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,1],[0,1,0,-1,1,0,1,0]],"dim":2},"189":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,1,0,0,0,1,0],[-2,0,1,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,1],[0,0,1,-1,0,0,-1,-1]],"dim":2},"19":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0]],"dim":1},"190":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,1,0,-1,1,0,1,0],[0,0,1,-1,0,0,-1,-1]],"dim":2},"191":{"A":[[-2,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,1,0,0,0,1,0,0],[1,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,-1,1,0],[1,1,1,-1,0,0,0,0]],"dim":2},"192":{"A":[[0,1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,-1,1,0],[1,0,0,1,-1,0,0,1]],"dim":2},"193":{"A":[[0,-1,1,0,0,0,0,0],[-1,2,0,1,0,0,0,0],[1,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,1,0,0,0,0,0,1]],"B":[[1,1,1,-1,0,0,0,0],[1,0,0,1,-1,0,0,1]],"dim":2},"194":{"A":[[1,0,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1]],"dim":2},"195":{"A":[[0,-1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[1,0,0,1,0,1,-1,0]],"dim":2},"196":{"A":[[0,-1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[1,0,0,-1,0,1,1,0]],"dim":2},"197":{"A":[[0,1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,-1,0,-1,0,0,1],[1,0,0,1,0,1,-1,0]],"dim":2},"198":{"A":[[0,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,-1,0,-1,0,0,1],[1,0,0,-1,0,1,1,0]],"dim":2},"199":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,1,-1,0],[1,0,0,-1,0,1,1,0]],"dim":2},"2":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0]],"dim":1},"20":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,1,0]],"dim":1},"200":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,-1,1,0,0],[1,-1,0,0,1,1,0,0]],"dim":2},"201":{"A":[[-1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[1,1,0,0,-1,1,0,0],[0,0,1,1,0,0,-1,-1]],"dim":2},"202":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[1,1,0,0,-1,1,0,0],[0,0,1,-1,0,0,1,-1]],"dim":2},"203":{"A":[[1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[1,-1,0,0,1,1,0,0],[0,0,1,1,0,0,-1,-1]],"dim":2},"204":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[1,-1,0,0,1,1,0,0],[0,0,1,-1,0,0,1,-1]],"dim":2},"205":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,0,1,1,0,0,-1,-1],[0,0,1,-1,0,0,1,-1]],"dim":2},"206":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,-1],[1,0,-1,0,0,1,0,1]],"dim":2},"207":{"A":[[-1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,-1],[0,1,0,1,-1,0,-1,0]],"dim":2},"208":{"A":[[-1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,-1],[0,1,0,-1,-1,0,1,0]],"dim":2},"209":{"A":[[1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,1,0,1],[0,1,0,1,-1,0,-1,0]],"dim":2},"21":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0]],"dim":1},"210":{"A":[[1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,1,0,1],[0,1,0,-1,-1,0,1,0]],"dim":2},"211":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,1,-1,0,-1,0],[0,1,0,-1,-1,0,1,0]],"dim":2},"212":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2]],"dim":2},"213":{"A":[[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[1,0,0,1,0,-1,-1,0]],"dim":2},"214":{"A":[[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[1,0,0,-1,0,1,-1,0]],"dim":2},"215":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0]],"B":[[0,0,0,0,0,0,0,2],[1,0,0,1,0,-1,-1,0]],"dim":2},"216":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0]],"B":[[0,0,0,0,0,0,0,2],[1,0,0,-1,0,1,-1,0]],"dim":2},"217":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,-1,-1,0],[1,0,0,-1,0,1,-1,0]],"dim":2},"218":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,1],[1,-1,0,0,0,0,-1,-1]],"dim":2},"219":{"A":[[0,0,1,0,0,0,0,0],[1,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[-2,1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,1],[0,1,0,1,0,-1,0,-1]],"dim":2},"22":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0]],"dim":1},"220":{"A":[[0,0,1,0,0,0,0,0],[-1,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,-1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[-2,1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,1],[0,1,0,-1,0,1,0,-1]],"dim":2},"221":{"A":[[0,0,1,0,0,0,0,0],[-1,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[2,1,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,-1,-1],[0,1,0,1,0,-1,0,-1]],"dim":2},"222":{"A":[[0,0,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,-1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[2,1,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,-1,-1],[0,1,0,-1,0,1,0,-1]],"dim":2},"223":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,0,1,0,-1,0,-1],[0,1,0,-1,0,1,0,-1]],"dim":2},"224":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,-1],[1,-1,0,0,0,0,-1,1]],"dim":2},"225":{"A":[[0,0,1,0,0,0,0,0],[1,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[2,-1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,-1],[0,1,0,1,0,-1,0,1]],"dim":2},"226":{"A":[[0,0,1,0,0,0,0,0],[-1,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,-1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[2,-1,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,-1],[0,1,0,-1,0,1,0,1]],"dim":2},"227":{"A":[[0,0,1,0,0,0,0,0],[-1,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[-2,-1,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,-1,1],[0,1,0,1,0,-1,0,1]],"dim":2},"228":{"A":[[0,0,1,0,0,0,0,0],[1,1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,-1,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[-2,-1,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,-1,1],[0,1,0,-1,0,1,0,1]],"dim":2},"229":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,0,1,0,-1,0,1],[0,1,0,-1,0,1,0,1]],"dim":2},"23":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0]],"dim":1},"230":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0]],"dim":2},"231":{"A":[[0,1,0,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[1,0,0,1,0,1,1,0]],"dim":2},"232":{"A":[[0,1,0,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[1,0,0,-1,0,-1,1,0]],"dim":2},"233":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[-1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,0,2,0,0,0],[1,0,0,1,0,1,1,0]],"dim":2},"234":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,0,2,0,0,0],[1,0,0,-1,0,-1,1,0]],"dim":2},"235":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,-1,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,1,1,0],[1,0,0,-1,0,-1,1,0]],"dim":2},"236":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[1,0,-1,0,-1,0,1,0]],"dim":2},"237":{"A":[[0,1,0,0,0,0,0,0],[1,0,-1,1,0,0,0,0],[-2,0,1,0,1,0,0,0],[1,0,-1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[0,0,1,1,-1,1,0,0]],"dim":2},"238":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,1,0,0,0,0],[-2,0,1,0,1,0,0,0],[-1,0,1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[0,0,1,-1,-1,-1,0,0]],"dim":2},"239":{"A":[[0,1,0,0,0,0,0,0],[-1,0,-1,1,0,0,0,0],[2,0,1,0,1,0,0,0],[-1,0,-1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0],[0,0,1,1,-1,1,0,0]],"dim":2},"24":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,1,1]],"dim":1},"240":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,1,0,0,0,0],[2,0,1,0,1,0,0,0],[1,0,1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0],[0,0,1,-1,-1,-1,0,0]],"dim":2},"241":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,0,-1,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,1,-1,1,0,0],[0,0,1,-1,-1,-1,0,0]],"dim":2},"242":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[1,0,-1,0,1,0,1,0]],"dim":2},"243":{"A":[[0,1,0,0,0,0,0,0],[1,0,-1,1,0,0,0,0],[2,0,-1,0,1,0,0,0],[1,0,-1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[0,0,1,1,1,1,0,0]],"dim":2},"244":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,1,0,0,0,0],[2,0,-1,0,1,0,0,0],[-1,0,1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[0,0,1,-1,1,-1,0,0]],"dim":2},"245":{"A":[[0,1,0,0,0,0,0,0],[-1,0,-1,1,0,0,0,0],[-2,0,-1,0,1,0,0,0],[-1,0,-1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,1,0],[0,0,1,1,1,1,0,0]],"dim":2},"246":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,1,0,0,0,0],[-2,0,-1,0,1,0,0,0],[1,0,1,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,1,0,1,0],[0,0,1,-1,1,-1,0,0]],"dim":2},"247":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,0,-1,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,1,1,1,0,0],[0,0,1,-1,1,-1,0,0]],"dim":2},"248":{"A":[[1,0,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1]],"dim":2},"249":{"A":[[0,-1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[1,0,0,1,0,-1,1,0]],"dim":2},"25":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,1,-1]],"dim":1},"250":{"A":[[0,-1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[1,0,0,-1,0,-1,-1,0]],"dim":2},"251":{"A":[[0,1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,-1,0,1,0,0,-1],[1,0,0,1,0,-1,1,0]],"dim":2},"252":{"A":[[0,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,-1,0,1,0,0,-1],[1,0,0,-1,0,-1,-1,0]],"dim":2},"253":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,0,0,1,0,-1,1,0],[1,0,0,-1,0,-1,-1,0]],"dim":2},"254":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,1,-1,0,0],[1,-1,0,0,-1,-1,0,0]],"dim":2},"255":{"A":[[-1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,1,0,0,1,-1,0,0],[0,0,1,1,0,0,1,1]],"dim":2},"256":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,1,0,0,1,-1,0,0],[0,0,1,-1,0,0,-1,1]],"dim":2},"257":{"A":[[1,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,-1,0,0,-1,-1,0,0],[0,0,1,1,0,0,1,1]],"dim":2},"258":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,-1,0,0,-1,-1,0,0],[0,0,1,-1,0,0,-1,1]],"dim":2},"259":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,0,1,1,0,0,1,1],[0,0,1,-1,0,0,-1,1]],"dim":2},"26":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,1]],"dim":1},"260":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,1],[1,0,-1,0,0,-1,0,-1]],"dim":2},"261":{"A":[[-1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,1],[0,1,0,1,1,0,1,0]],"dim":2},"262":{"A":[[-1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,1],[0,1,0,-1,1,0,-1,0]],"dim":2},"263":{"A":[[1,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,-1,0,-1],[0,1,0,1,1,0,1,0]],"dim":2},"264":{"A":[[1,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,-1,0,-1],[0,1,0,-1,1,0,-1,0]],"dim":2},"265":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,1,1,0,1,0],[0,1,0,-1,1,0,-1,0]],"dim":2},"266":{"A":[[1,0,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2]],"dim":4},"267":{"A":[[0,-1,1,0,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,1,1,1,0,0,0,0]],"dim":4},"268":{"A":[[0,0,0,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0]],"dim":4},"269":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,-1,0,0,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,0,1,-1,0,1,0],[0,0,1,1,0,0,1,1]],"dim":4},"27":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,1,0,0,0,0,-1,-1]],"dim":1},"270":{"A":[[0,0,0,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0]],"dim":4},"271":{"A":[[1,0,0,0,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,1,0,0,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1]],"dim":4},"272":{"A":[[0,0,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[1,1,0,0,-1,1,0,0],[1,0,1,0,0,1,0,1]],"dim":4},"273":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,-1,0,1,0,0,1],[0,0,1,1,-1,1,0,0]],"dim":4},"274":{"A":[[0,0,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1]],"dim":4},"275":{"A":[[1,0,0,0,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[0,0,1,1,1,1,0,0]],"dim":4},"276":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[0,1,-1,0,0,1,1,0]],"dim":4},"277":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0]],"dim":4},"278":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,0,1,1,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,0,0,0,1,1,-1,1],[1,0,0,-1,1,0,0,1]],"dim":4},"279":{"A":[[0,1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[0,1,-1,0,0,-1,1,0],[1,-1,1,1,0,0,0,0]],"dim":4},"28":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,1,1]],"dim":1},"280":{"A":[[1,1,-1,1,0,0,0,0],[1,1,0,0,1,1,0,0],[-1,0,1,0,-1,0,1,0],[2,1,-1,0,1,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,-1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":4},"281":{"A":[[1,-1,1,1,0,0,0,0],[-1,1,0,0,1,1,0,0],[1,0,1,0,-1,0,1,0],[-2,1,-1,0,1,0,0,1]],"B":[[1,0,-1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,-1,0,0],[1,0,0,-1,1,0,0,1]],"dim":4},"282":{"A":[[1,1,-1,1,0,0,0,0],[1,1,0,0,-1,1,0,0],[-1,0,1,0,1,0,1,0],[-2,-1,1,0,1,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":4},"283":{"A":[[1,-1,1,1,0,0,0,0],[-1,1,0,0,-1,1,0,0],[1,0,1,0,1,0,1,0],[2,-1,1,0,1,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,-1,-1,0,0],[1,0,0,-1,-1,0,0,-1]],"dim":4},"284":{"A":[[1,1,-1,1,0,0,0,0],[-1,-1,0,0,1,1,0,0],[1,0,-1,0,-1,0,1,0],[-2,-1,1,0,1,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,1],[1,-1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":4},"285":{"A":[[1,-1,1,1,0,0,0,0],[1,-1,0,0,1,1,0,0],[-1,0,-1,0,-1,0,1,0],[2,-1,1,0,1,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,-1,1,0,0],[1,0,0,-1,-1,0,0,-1]],"dim":4},"286":{"A":[[1,1,-1,1,0,0,0,0],[-1,-1,0,0,-1,1,0,0],[1,0,-1,0,1,0,1,0],[2,1,-1,0,1,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[1,-1,0,0,0,0,-1,-1],[1,-1,0,0,-1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":4},"287":{"A":[[1,-1,1,1,0,0,0,0],[1,-1,0,0,-1,1,0,0],[-1,0,-1,0,1,0,1,0],[-2,1,-1,0,1,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,1,0,0],[1,0,0,-1,1,0,0,1]],"dim":4},"288":{"A":[[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,-1,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,1,1,0,0,1,1,0],[1,1,1,1,0,0,0,0]],"dim":4},"289":{"A":[[0,-1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,0,-1,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,1,0,0,1,1,0],[1,1,1,-1,0,0,0,0]],"dim":4},"29":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[-1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,1,-1]],"dim":1},"290":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,0,-1,1,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,0,0,0,1,1,1,-1],[1,0,0,1,1,0,0,-1]],"dim":4},"291":{"A":[[0,1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,0,-1,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[0,1,-1,0,0,1,1,0],[1,1,-1,-1,0,0,0,0]],"dim":4},"292":{"A":[[-1,-1,1,1,0,0,0,0],[1,1,0,0,1,1,0,0],[1,0,-1,0,1,0,1,0],[2,1,-1,0,1,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[1,-1,0,0,0,0,-1,-1],[1,-1,0,0,-1,1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":4},"293":{"A":[[-1,1,-1,1,0,0,0,0],[-1,1,0,0,1,1,0,0],[-1,0,-1,0,1,0,1,0],[-2,1,-1,0,1,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":4},"294":{"A":[[-1,-1,1,1,0,0,0,0],[1,1,0,0,-1,1,0,0],[1,0,-1,0,-1,0,1,0],[-2,-1,1,0,1,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,1],[1,-1,0,0,1,1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":4},"295":{"A":[[-1,1,-1,1,0,0,0,0],[-1,1,0,0,-1,1,0,0],[-1,0,-1,0,-1,0,1,0],[2,-1,1,0,1,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,-1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":4},"296":{"A":[[-1,-1,1,1,0,0,0,0],[-1,-1,0,0,1,1,0,0],[-1,0,1,0,1,0,1,0],[-2,-1,1,0,1,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":4},"297":{"A":[[-1,1,-1,1,0,0,0,0],[1,-1,0,0,1,1,0,0],[1,0,1,0,1,0,1,0],[2,-1,1,0,1,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,-1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":4},"298":{"A":[[-1,-1,1,1,0,0,0,0],[-1,-1,0,0,-1,1,0,0],[-1,0,1,0,-1,0,1,0],[2,1,-1,0,1,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,-1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":4},"299":{"A":[[-1,1,-1,1,0,0,0,0],[1,-1,0,0,-1,1,0,0],[1,0,1,0,-1,0,1,0],[-2,1,-1,0,1,0,0,1]],"B":[[1,0,-1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":4},"3":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0]],"dim":1},"30":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,-1,1]],"dim":1},"300":{"A":[[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,1,1,0,0,1,-1,0],[1,1,1,-1,0,0,0,0]],"dim":4},"301":{"A":[[0,-1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,0,1,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,1,0,0,1,-1,0],[1,1,1,1,0,0,0,0]],"dim":4},"302":{"A":[[-1,-1,-1,1,0,0,0,0],[-1,-1,0,0,-1,1,0,0],[-1,0,-1,0,-1,0,1,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,-1,-1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":4},"303":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,-1,0,1,0,0],[-1,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,0,0,1,1],[0,1,0,1,0,1,0,1]],"dim":4},"304":{"A":[[0,0,1,0,1,0,0,0],[0,0,0,1,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[0,0,1,1,-1,-1,0,0]],"dim":4},"305":{"A":[[0,0,-1,0,1,0,0,0],[0,0,0,-1,0,1,0,0],[1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[0,0,1,1,1,1,0,0]],"dim":4},"306":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,1,0,1,0,0],[1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[0,0,1,1,1,-1,0,0]],"dim":4},"307":{"A":[[-1,1,1,1,0,0,0,0],[-1,1,0,0,1,1,0,0],[-1,0,1,0,1,0,1,0],[2,-1,-1,0,-1,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":4},"308":{"A":[[-1,-1,-1,1,0,0,0,0],[1,1,0,0,1,1,0,0],[1,0,1,0,1,0,1,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0],[1,-1,0,0,0,0,-1,1],[1,-1,0,0,-1,1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":4},"309":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,0,-1,0,1],[0,0,1,1,0,0,-1,1]],"dim":4},"31":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[1,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,0,0,-1,-1]],"dim":1},"310":{"A":[[0,1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,1,0,0,-1,-1,0,0],[0,1,0,1,-1,0,1,0]],"dim":4},"311":{"A":[[0,-1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,1,0,0,1,1,0,0],[0,1,0,1,1,0,-1,0]],"dim":4},"312":{"A":[[0,0,1,0,0,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,1,0,0,1,1,0,0],[0,1,0,1,1,0,1,0]],"dim":4},"313":{"A":[[-1,1,1,1,0,0,0,0],[1,-1,0,0,-1,1,0,0],[1,0,-1,0,-1,0,1,0],[2,-1,-1,0,-1,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":4},"314":{"A":[[1,-1,-1,1,0,0,0,0],[-1,1,0,0,1,1,0,0],[1,0,-1,0,-1,0,1,0],[2,-1,-1,0,-1,0,0,1]],"B":[[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":4},"315":{"A":[[1,1,1,1,0,0,0,0],[1,1,0,0,-1,1,0,0],[-1,0,-1,0,1,0,1,0],[2,1,1,0,-1,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,1,1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":4},"316":{"A":[[1,-1,-1,1,0,0,0,0],[-1,1,0,0,-1,1,0,0],[1,0,-1,0,1,0,1,0],[-2,1,1,0,-1,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":4},"317":{"A":[[1,1,1,1,0,0,0,0],[-1,-1,0,0,1,1,0,0],[1,0,1,0,-1,0,1,0],[2,1,1,0,-1,0,0,1]],"B":[[1,0,-1,0,1,0,1,0],[1,-1,0,0,0,0,-1,-1],[1,-1,0,0,1,-1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":4},"318":{"A":[[1,-1,-1,1,0,0,0,0],[1,-1,0,0,1,1,0,0],[-1,0,1,0,-1,0,1,0],[-2,1,1,0,-1,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":4},"319":{"A":[[1,1,1,1,0,0,0,0],[-1,-1,0,0,-1,1,0,0],[1,0,1,0,1,0,1,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[1,0,-1,0,-1,0,1,0],[1,-1,0,0,0,0,-1,1],[1,-1,0,0,-1,-1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":4},"32":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,1,1,0,0]],"dim":1},"320":{"A":[[0,0,-1,0,1,0,0,0],[0,0,0,1,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[0,0,1,1,1,-1,0,0]],"dim":4},"321":{"A":[[0,0,1,0,1,0,0,0],[0,0,0,-1,0,1,0,0],[1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[0,0,1,1,-1,1,0,0]],"dim":4},"322":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,0,1,0,1],[0,0,1,1,0,0,1,1]],"dim":4},"323":{"A":[[0,0,1,0,0,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,1,0,0,1,-1,0,0],[0,1,0,1,1,0,-1,0]],"dim":4},"324":{"A":[[-1,-1,-1,1,0,0,0,0],[1,1,0,0,-1,1,0,0],[1,0,1,0,-1,0,1,0],[2,1,1,0,-1,0,0,1]],"B":[[1,0,-1,0,1,0,1,0],[1,-1,0,0,0,0,-1,-1],[1,-1,0,0,1,1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":4},"325":{"A":[[-1,1,1,1,0,0,0,0],[1,-1,0,0,1,1,0,0],[1,0,-1,0,1,0,1,0],[-2,1,1,0,-1,0,0,1]],"B":[[1,0,1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":4},"326":{"A":[[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2]],"dim":6},"327":{"A":[[0,0,0,0,0,1,0,0],[0,-1,-1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"328":{"A":[[0,0,0,0,0,1,0,0],[0,1,1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0]],"dim":6},"329":{"A":[[0,0,0,0,0,0,1,0],[0,-1,-1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,-1,0,1,0,0,1],[1,1,0,0,-1,1,0,0],[1,0,1,0,0,1,0,1]],"dim":6},"33":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,1,-1,0,0]],"dim":1},"330":{"A":[[0,0,0,0,0,0,1,0],[0,1,1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,1,-1,-1,0,0,0,0]],"dim":6},"331":{"A":[[0,1,1,0,0,0,0,0],[0,0,0,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[0,1,-1,0,0,1,1,0]],"dim":6},"332":{"A":[[0,1,1,0,0,0,0,0],[0,0,0,0,0,1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[0,1,-1,0,0,-1,1,0]],"dim":6},"333":{"A":[[0,1,1,0,0,1,1,0],[0,-1,-1,0,-1,-2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"334":{"A":[[0,1,1,0,0,1,1,0],[0,1,1,0,-1,2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,-1,-1,0,0]],"dim":6},"335":{"A":[[0,-1,-1,0,0,1,1,0],[0,1,1,0,-1,-2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,-1,1,0,0]],"dim":6},"336":{"A":[[0,-1,-1,0,0,1,1,0],[0,-1,-1,0,-1,2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"337":{"A":[[0,0,0,0,0,-1,1,0],[0,0,0,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,1,1,0]],"dim":6},"338":{"A":[[0,1,1,0,0,0,0,0],[0,0,0,0,0,-1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[0,1,-1,0,0,1,1,0]],"dim":6},"339":{"A":[[0,-1,-1,0,0,-1,1,0],[0,-1,-1,0,-1,-2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"34":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,-1,1,0,0]],"dim":1},"340":{"A":[[0,-1,-1,0,0,-1,1,0],[0,1,1,0,-1,2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,-1,-1,0,0]],"dim":6},"341":{"A":[[0,1,1,0,0,-1,1,0],[0,1,1,0,-1,-2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,-1,1,0,0]],"dim":6},"342":{"A":[[0,1,1,0,0,-1,1,0],[0,-1,-1,0,-1,2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"343":{"A":[[0,0,0,0,0,1,1,0],[0,0,0,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,1],[0,1,1,0,0,1,-1,0]],"dim":6},"344":{"A":[[1,0,0,0,0,0,0,0],[0,0,0,1,0,0,0,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":6},"345":{"A":[[1,0,0,0,0,0,0,0],[0,1,-1,0,1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,1,0,0,1,1,0],[0,1,0,1,-1,0,1,0]],"dim":6},"346":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[0,1,1,0,0,1,1,0]],"dim":6},"347":{"A":[[0,0,0,1,0,0,0,0],[0,1,-1,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,-1,1,0,0]],"dim":6},"348":{"A":[[0,0,0,1,0,0,0,0],[0,-1,1,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0]],"dim":6},"349":{"A":[[0,-1,1,0,0,0,0,0],[0,0,0,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,1,0,0,1,1,0]],"dim":6},"35":{"A":[[-1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,0,0,-1,-1,0,0]],"dim":1},"350":{"A":[[0,-1,1,0,0,0,0,0],[1,0,0,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,1,-1,0,0,0,0]],"dim":6},"351":{"A":[[1,1,-1,1,0,0,0,0],[2,1,-1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,-1,0,0,0,0,1,-1],[1,-1,1,1,0,0,0,0]],"dim":6},"352":{"A":[[1,1,-1,1,0,0,0,0],[-2,-1,1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,-1,0,0,1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"353":{"A":[[1,-1,1,1,0,0,0,0],[2,-1,1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,0,0,-1,-1,0,0,-1]],"dim":6},"354":{"A":[[1,-1,1,1,0,0,0,0],[-2,1,-1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,1,0,1,0],[1,1,0,0,0,0,1,1],[1,0,0,-1,1,0,0,1]],"dim":6},"355":{"A":[[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,1,1,0,0,0,0]],"dim":6},"356":{"A":[[0,-1,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,1,1,0,0,0,0]],"dim":6},"357":{"A":[[-1,-1,1,1,0,0,0,0],[2,1,-1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,-1,0,0,0,0,1,-1],[1,-1,1,-1,0,0,0,0]],"dim":6},"358":{"A":[[-1,-1,1,1,0,0,0,0],[-2,-1,1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,-1,0,0,1,1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"359":{"A":[[-1,1,-1,1,0,0,0,0],[2,-1,1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"36":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,1,1,0,0]],"dim":1},"360":{"A":[[-1,1,-1,1,0,0,0,0],[-2,1,-1,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,1,0,1,0],[1,1,0,0,0,0,1,1],[1,1,-1,-1,0,0,0,0]],"dim":6},"361":{"A":[[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,1,-1,0,0,0,0]],"dim":6},"362":{"A":[[-1,0,-1,0,-1,0,1,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,-1,0,1,0,0,1],[1,0,-1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,-1,1,0,0,0,0]],"dim":6},"363":{"A":[[0,0,-1,-1,1,1,0,0],[-1,0,-1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":6},"364":{"A":[[-1,0,-1,0,-1,0,1,0],[0,1,0,1,0,1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,-1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"365":{"A":[[0,0,-1,-1,1,1,0,0],[-1,-1,0,0,0,0,-1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"366":{"A":[[1,2,0,1,0,1,1,0],[0,1,0,1,0,1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"367":{"A":[[0,0,-1,-1,1,1,0,0],[0,1,1,2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"368":{"A":[[1,1,0,0,1,1,0,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[1,0,-1,0,-1,0,1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,-1,1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":6},"369":{"A":[[1,1,0,0,1,1,0,0],[0,1,0,1,-1,0,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,-1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"37":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,1,-1,0,0]],"dim":1},"370":{"A":[[1,1,0,0,1,1,0,0],[0,0,1,1,0,0,-1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,-1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,-1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"371":{"A":[[0,1,0,1,-1,0,1,0],[-1,0,-1,0,0,1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,-1,0,1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"372":{"A":[[-1,0,-2,-1,0,1,1,0],[-1,0,-1,0,0,1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":6},"373":{"A":[[0,1,0,1,-1,0,1,0],[0,1,1,2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":6},"374":{"A":[[0,1,-1,0,0,1,1,0],[0,1,-1,0,1,2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"375":{"A":[[1,1,1,1,0,0,0,0],[0,1,-1,0,0,1,1,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":6},"376":{"A":[[0,1,-1,0,0,1,1,0],[-1,0,0,1,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,-1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"377":{"A":[[1,1,1,1,0,0,0,0],[0,0,0,0,1,1,-1,1]],"B":[[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,-1,0,1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,-1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"378":{"A":[[-1,0,0,1,-2,-1,1,0],[-1,0,0,1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"379":{"A":[[1,1,1,1,0,0,0,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,-1,0,-1,0,1,0],[1,-1,0,0,0,0,1,1],[1,-1,-1,1,0,0,0,0]],"dim":6},"38":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,-1,1,0,0]],"dim":1},"380":{"A":[[-1,0,1,0,-1,0,1,0],[-2,1,1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,1,0,0]],"dim":6},"381":{"A":[[0,0,-1,-1,-1,1,0,0],[-1,0,1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"382":{"A":[[-1,0,1,0,-1,0,1,0],[0,-1,0,-1,0,-1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"383":{"A":[[0,0,-1,-1,-1,1,0,0],[-1,1,0,0,0,0,-1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"384":{"A":[[1,-2,0,-1,0,-1,1,0],[0,-1,0,-1,0,-1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"385":{"A":[[0,0,-1,-1,-1,1,0,0],[0,-1,-1,-2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"386":{"A":[[-1,1,0,0,-1,1,0,0],[-2,1,1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,-1,0,0]],"dim":6},"387":{"A":[[-1,1,0,0,-1,1,0,0],[0,-1,0,-1,-1,0,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"388":{"A":[[-1,1,0,0,-1,1,0,0],[0,0,-1,-1,0,0,-1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"389":{"A":[[0,-1,0,-1,-1,0,1,0],[-1,0,1,0,0,-1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"39":{"A":[[1,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,0,0,-1,-1,0,0]],"dim":1},"390":{"A":[[-1,0,2,1,0,-1,1,0],[-1,0,1,0,0,-1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"391":{"A":[[0,-1,0,-1,-1,0,1,0],[0,-1,-1,-2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"392":{"A":[[0,-1,1,0,0,-1,1,0],[0,-1,1,0,1,-2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,-1,0,0]],"dim":6},"393":{"A":[[-1,1,1,1,0,0,0,0],[0,-1,1,0,0,-1,1,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"394":{"A":[[0,-1,1,0,0,-1,1,0],[-1,0,0,-1,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"395":{"A":[[-1,1,1,1,0,0,0,0],[0,0,0,0,1,-1,-1,1]],"B":[[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"396":{"A":[[-1,0,0,-1,-2,1,1,0],[-1,0,0,-1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"397":{"A":[[-1,1,1,1,0,0,0,0],[-2,1,1,0,-1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"398":{"A":[[-1,0,1,0,1,0,1,0],[2,-1,-1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,1,1,0,0,0,0]],"dim":6},"399":{"A":[[0,0,1,-1,-1,1,0,0],[-1,0,1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"4":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0]],"dim":1},"40":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,1]],"dim":1},"400":{"A":[[-1,0,1,0,1,0,1,0],[0,1,0,-1,0,-1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"401":{"A":[[0,0,1,-1,-1,1,0,0],[1,-1,0,0,0,0,1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"402":{"A":[[1,-2,0,1,0,1,1,0],[0,1,0,-1,0,-1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"403":{"A":[[0,0,1,-1,-1,1,0,0],[0,1,1,-2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"404":{"A":[[1,-1,0,0,-1,1,0,0],[2,-1,-1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"405":{"A":[[1,-1,0,0,-1,1,0,0],[0,-1,0,1,1,0,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"406":{"A":[[1,-1,0,0,-1,1,0,0],[0,0,1,-1,0,0,1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"407":{"A":[[0,-1,0,1,1,0,1,0],[1,0,-1,0,0,-1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"408":{"A":[[-1,0,2,-1,0,1,1,0],[1,0,-1,0,0,-1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"409":{"A":[[0,-1,0,1,1,0,1,0],[0,1,1,-2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,1,1,0,0,0,0]],"dim":6},"41":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,1,0,-1]],"dim":1},"410":{"A":[[0,-1,1,0,0,1,1,0],[0,1,-1,0,1,-2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"411":{"A":[[1,-1,-1,1,0,0,0,0],[0,-1,1,0,0,1,1,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"412":{"A":[[0,-1,1,0,0,1,1,0],[1,0,0,-1,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"413":{"A":[[1,-1,-1,1,0,0,0,0],[0,0,0,0,1,-1,1,1]],"B":[[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"414":{"A":[[-1,0,0,1,2,-1,1,0],[1,0,0,-1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"415":{"A":[[1,-1,-1,1,0,0,0,0],[2,-1,-1,0,-1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,1,-1],[1,1,1,1,0,0,0,0]],"dim":6},"416":{"A":[[-1,0,-1,0,1,0,1,0],[2,1,1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,1,1,0,0]],"dim":6},"417":{"A":[[0,0,1,-1,1,1,0,0],[-1,0,-1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"418":{"A":[[-1,0,-1,0,1,0,1,0],[0,-1,0,1,0,1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,1,1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":6},"419":{"A":[[0,0,1,-1,1,1,0,0],[1,1,0,0,0,0,1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"42":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,1]],"dim":1},"420":{"A":[[1,2,0,-1,0,-1,1,0],[0,-1,0,1,0,1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"421":{"A":[[0,0,1,-1,1,1,0,0],[0,-1,-1,2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"422":{"A":[[-1,-1,0,0,1,1,0,0],[2,1,1,0,-1,0,0,1]],"B":[[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,-1,0,0,1,-1,0,0]],"dim":6},"423":{"A":[[-1,-1,0,0,1,1,0,0],[0,1,0,-1,1,0,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"424":{"A":[[-1,-1,0,0,1,1,0,0],[0,0,-1,1,0,0,1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"425":{"A":[[0,1,0,-1,1,0,1,0],[1,0,1,0,0,1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,-1,0,1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,-1,-1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":6},"426":{"A":[[-1,0,-2,1,0,-1,1,0],[1,0,1,0,0,1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"427":{"A":[[0,1,0,-1,1,0,1,0],[0,-1,-1,2,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,0,0,2,0,0],[1,0,1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"428":{"A":[[0,1,-1,0,0,-1,1,0],[0,-1,1,0,1,2,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,1,0,0]],"dim":6},"429":{"A":[[-1,-1,-1,1,0,0,0,0],[0,1,-1,0,0,-1,1,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,1,-1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":6},"43":{"A":[[0,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,1,0,0,-1,0,-1]],"dim":1},"430":{"A":[[0,1,-1,0,0,-1,1,0],[1,0,0,1,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,1,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"431":{"A":[[-1,-1,-1,1,0,0,0,0],[0,0,0,0,1,1,1,1]],"B":[[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,-1,0,1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,-1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"432":{"A":[[-1,0,0,-1,2,1,1,0],[1,0,0,1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"433":{"A":[[-1,-1,-1,1,0,0,0,0],[2,1,1,0,-1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,-1,0,0,1,1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":6},"434":{"A":[[0,-1,0,0,1,0,0,0],[0,0,-1,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1]],"dim":6},"435":{"A":[[-1,0,0,-1,0,-1,1,0],[0,-1,-1,0,1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"436":{"A":[[1,0,0,-1,0,1,1,0],[0,-1,-1,0,1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"437":{"A":[[-1,0,0,-1,0,-1,1,0],[0,1,-1,0,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"438":{"A":[[1,0,0,-1,0,1,1,0],[0,1,-1,0,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"439":{"A":[[1,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,1,-1,0,0],[0,1,0,1,1,0,1,0]],"dim":6},"44":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,1,0,1]],"dim":1},"440":{"A":[[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,0,0,1,-1,0,0]],"dim":6},"441":{"A":[[1,1,0,0,-1,1,0,0],[0,0,-1,-1,0,0,1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"442":{"A":[[1,1,0,0,-1,1,0,0],[0,0,-1,1,0,0,-1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"443":{"A":[[1,-1,0,0,1,1,0,0],[0,0,-1,-1,0,0,1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"444":{"A":[[1,-1,0,0,1,1,0,0],[0,0,-1,1,0,0,-1,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"445":{"A":[[0,0,0,-1,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[0,1,0,1,1,0,1,0]],"dim":6},"446":{"A":[[1,0,0,0,0,1,0,0],[0,0,-1,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,1,0,0,1,-1,0,0]],"dim":6},"447":{"A":[[0,-1,0,-1,1,0,1,0],[-1,0,-1,0,0,-1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,-1,0,1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"448":{"A":[[0,1,0,-1,-1,0,1,0],[-1,0,-1,0,0,-1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,-1,0,1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":6},"449":{"A":[[0,-1,0,-1,1,0,1,0],[1,0,-1,0,0,1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"45":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,1,0,-1]],"dim":1},"450":{"A":[[0,1,0,-1,-1,0,1,0],[1,0,-1,0,0,1,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"451":{"A":[[0,-1,0,0,1,0,0,0],[0,0,0,-1,0,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[0,1,0,1,1,0,1,0]],"dim":6},"452":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0]],"dim":6},"453":{"A":[[0,1,0,0,0,0,0,0],[-1,0,0,-1,0,1,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,0,1,0,0,1,0,1],[1,0,0,-1,1,0,0,1]],"dim":6},"454":{"A":[[0,1,0,0,0,0,0,0],[-1,0,0,1,0,-1,1,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,0,1,0,0,-1,0,1],[1,0,0,1,1,0,0,-1]],"dim":6},"455":{"A":[[-1,0,0,-1,0,1,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"456":{"A":[[-1,0,0,1,0,-1,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"457":{"A":[[0,0,0,-1,0,1,0,0],[-1,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[0,0,1,1,1,1,0,0]],"dim":6},"458":{"A":[[-1,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0]],"dim":6},"459":{"A":[[-1,-2,0,-1,0,1,1,0],[0,-1,0,-1,0,1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,-1],[1,-1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"46":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,-1,0,1]],"dim":1},"460":{"A":[[-1,-2,0,1,0,-1,1,0],[0,-1,0,1,0,-1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,-1],[1,-1,0,0,1,1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"461":{"A":[[-1,2,0,1,0,-1,1,0],[0,-1,0,-1,0,1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"462":{"A":[[-1,2,0,-1,0,1,1,0],[0,-1,0,1,0,-1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"463":{"A":[[0,0,0,-1,0,1,0,0],[0,-1,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[0,0,1,1,1,1,0,0]],"dim":6},"464":{"A":[[-1,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0]],"dim":6},"465":{"A":[[-1,-2,0,-1,0,1,1,0],[0,1,0,1,0,-1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,1],[1,-1,0,0,1,-1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"466":{"A":[[-1,-2,0,1,0,-1,1,0],[0,1,0,-1,0,1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,1],[1,-1,0,0,1,1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"467":{"A":[[-1,2,0,1,0,-1,1,0],[0,1,0,1,0,-1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"468":{"A":[[-1,2,0,-1,0,1,1,0],[0,1,0,-1,0,1,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,-1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"469":{"A":[[0,0,0,-1,0,1,0,0],[0,1,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,0,1,1,1,1,0,0]],"dim":6},"47":{"A":[[0,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,-1,0,0,-1,0,-1]],"dim":1},"470":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":6},"471":{"A":[[0,0,1,0,0,0,0,0],[1,0,0,1,0,1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,-1,0,0],[1,0,0,-1,1,0,0,1]],"dim":6},"472":{"A":[[0,0,1,0,0,0,0,0],[1,0,0,-1,0,-1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,1,0,0],[1,0,0,1,1,0,0,-1]],"dim":6},"473":{"A":[[0,0,0,0,1,0,0,0],[1,0,0,1,0,1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,0,0,-1,1],[1,0,1,0,0,-1,0,1],[1,1,1,-1,0,0,0,0]],"dim":6},"474":{"A":[[0,0,0,0,1,0,0,0],[1,0,0,-1,0,-1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,0,0,-1,1],[1,0,1,0,0,1,0,1],[1,1,1,1,0,0,0,0]],"dim":6},"475":{"A":[[0,0,0,1,0,1,0,0],[1,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[0,0,1,1,1,-1,0,0]],"dim":6},"476":{"A":[[0,0,1,0,1,0,0,0],[1,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,-1,0]],"dim":6},"477":{"A":[[0,0,1,1,-1,1,0,0],[1,0,1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,-1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":6},"478":{"A":[[0,0,-1,1,1,1,0,0],[1,0,1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"479":{"A":[[0,0,1,1,-1,1,0,0],[1,0,-1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"48":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,1,0,0,1,1,0]],"dim":1},"480":{"A":[[0,0,-1,1,1,1,0,0],[1,0,-1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"481":{"A":[[0,0,-1,0,1,0,0,0],[0,0,0,1,0,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[0,0,1,1,1,-1,0,0]],"dim":6},"482":{"A":[[0,0,-1,0,1,0,0,0],[1,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0]],"dim":6},"483":{"A":[[0,0,1,1,1,1,0,0],[1,0,1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,-1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":6},"484":{"A":[[0,0,-1,1,-1,1,0,0],[1,0,1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,-1,0,1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"485":{"A":[[0,0,1,1,1,1,0,0],[1,0,-1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"486":{"A":[[0,0,-1,1,-1,1,0,0],[1,0,-1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,-1,0,1,0],[1,1,0,0,0,0,-1,1],[1,1,0,0,-1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"487":{"A":[[0,0,1,0,1,0,0,0],[0,0,0,1,0,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[0,0,1,1,-1,-1,0,0]],"dim":6},"488":{"A":[[0,1,0,0,1,0,0,0],[0,0,1,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1]],"dim":6},"489":{"A":[[1,0,0,1,0,-1,1,0],[0,1,1,0,1,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,-1,0,-1,0],[1,1,0,0,-1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"49":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,1,0,0,1,-1,0]],"dim":1},"490":{"A":[[-1,0,0,1,0,1,1,0],[0,1,1,0,1,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"491":{"A":[[1,0,0,1,0,-1,1,0],[0,-1,1,0,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,-1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"492":{"A":[[-1,0,0,1,0,1,1,0],[0,-1,1,0,-1,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,-1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"493":{"A":[[-1,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,1,1,0,0],[0,1,0,1,1,0,-1,0]],"dim":6},"494":{"A":[[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,1,0,0,-1,1,0,0]],"dim":6},"495":{"A":[[-1,-1,0,0,-1,1,0,0],[0,0,1,1,0,0,1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,-1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,-1,1,-1,0,0,0,0]],"dim":6},"496":{"A":[[-1,-1,0,0,-1,1,0,0],[0,0,1,-1,0,0,-1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,-1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,-1,1,0,0],[1,-1,1,1,0,0,0,0]],"dim":6},"497":{"A":[[-1,1,0,0,1,1,0,0],[0,0,1,1,0,0,1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"498":{"A":[[-1,1,0,0,1,1,0,0],[0,0,1,-1,0,0,-1,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,-1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"499":{"A":[[0,0,0,1,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[0,1,0,1,1,0,-1,0]],"dim":6},"5":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,2,0,0,0,0]],"dim":1},"50":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,1,0,0,-1,1,0]],"dim":1},"500":{"A":[[-1,0,0,0,0,1,0,0],[0,0,1,0,0,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,0,0,1,1,0,0]],"dim":6},"501":{"A":[[0,1,0,1,1,0,1,0],[1,0,1,0,0,-1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,-1,0,1,0,-1,0],[1,0,-1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,1,-1,-1,0,0,0,0]],"dim":6},"502":{"A":[[0,-1,0,1,-1,0,1,0],[1,0,1,0,0,-1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,-1,0,1,0,1,0],[1,0,-1,0,-1,0,-1,0],[1,1,0,0,-1,1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":6},"503":{"A":[[0,1,0,1,1,0,1,0],[-1,0,1,0,0,1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":6},"504":{"A":[[0,-1,0,1,-1,0,1,0],[-1,0,1,0,0,1,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0],[1,1,0,0,-1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":6},"505":{"A":[[0,1,0,0,1,0,0,0],[0,0,0,1,0,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[0,1,0,1,-1,0,-1,0]],"dim":6},"506":{"A":[[1,0,0,0,0,0,0,0],[0,-1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,1,0,0,1,1,0]],"dim":4},"507":{"A":[[0,1,1,0,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,-1,0,1,0,0,1],[1,1,-1,-1,0,0,0,0]],"dim":4},"508":{"A":[[-1,-1,-1,1,0,0,0,0],[-1,-1,0,0,1,1,0,0],[-1,0,-1,0,1,0,1,0],[2,1,1,0,-1,0,0,1]],"B":[[1,0,-1,0,1,0,-1,0],[1,-1,0,0,0,0,1,-1],[1,-1,0,0,1,-1,0,0],[1,-1,-1,-1,0,0,0,0]],"dim":4},"509":{"A":[[-1,1,1,1,0,0,0,0],[-1,1,0,0,-1,1,0,0],[-1,0,1,0,-1,0,1,0],[-2,1,1,0,-1,0,0,1]],"B":[[1,0,1,0,-1,0,-1,0],[1,1,0,0,0,0,1,1],[1,1,0,0,-1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":4},"51":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,1,1,0]],"dim":1},"510":{"A":[[0,1,1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0]],"dim":7},"511":{"A":[[0,-1,1,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0]],"dim":7},"512":{"A":[[0,-1,-1,0,0,1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"513":{"A":[[0,-1,1,0,0,-1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"514":{"A":[[0,0,0,0,1,1,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"515":{"A":[[1,1,-1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"516":{"A":[[1,0,0,1,1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"517":{"A":[[0,0,-1,-1,0,0,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"518":{"A":[[0,-1,0,1,0,1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"519":{"A":[[1,-1,-1,1,0,0,0,0],[1,-1,0,0,-1,1,0,0],[-1,0,1,0,1,0,1,0],[2,-1,-1,0,-1,0,0,1]],"B":[[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":4},"52":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,-1,1,0]],"dim":1},"520":{"A":[[1,1,1,1,0,0,0,0],[1,1,0,0,1,1,0,0],[-1,0,-1,0,-1,0,1,0],[-2,-1,-1,0,-1,0,0,1]],"B":[[1,0,-1,0,-1,0,-1,0],[1,-1,0,0,0,0,1,1],[1,-1,0,0,-1,1,0,0],[1,-1,-1,1,0,0,0,0]],"dim":4},"521":{"A":[[0,1,0,0,1,0,0,0],[-1,0,0,0,0,1,0,0],[0,0,0,1,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1],[1,1,0,0,-1,1,0,0],[0,1,0,1,-1,0,-1,0]],"dim":4},"522":{"A":[[0,0,1,0,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,1,0,1,0,0],[1,0,0,0,0,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,0,2],[1,1,0,0,0,0,-1,1],[0,1,0,1,0,-1,0,1]],"dim":4},"523":{"A":[[0,1,0,0,0,0,0,0],[0,0,0,-1,0,1,0,0],[-1,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[1,0,1,0,1,0,1,0],[0,0,1,1,1,1,0,0]],"dim":4},"524":{"A":[[0,-1,0,0,1,0,0,0],[1,0,0,0,0,1,0,0],[0,0,0,-1,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[1,1,0,0,1,-1,0,0],[0,1,0,1,1,0,1,0]],"dim":4},"525":{"A":[[1,0,0,0,0,0,0,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":7},"526":{"A":[[0,1,0,0,0,0,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":7},"527":{"A":[[0,0,1,0,0,0,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":7},"528":{"A":[[0,0,0,1,0,0,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":7},"529":{"A":[[0,0,0,0,1,0,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":7},"53":{"A":[[1,0,0,0,0,0,0,0],[0,1,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,1,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,-1,0,0,-1,-1,0]],"dim":1},"530":{"A":[[0,0,0,0,0,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2]],"dim":7},"531":{"A":[[0,0,0,0,0,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2]],"dim":7},"532":{"A":[[0,0,0,0,0,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0]],"dim":7},"533":{"A":[[0,1,1,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1]],"dim":7},"534":{"A":[[0,-1,-1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,-1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0]],"dim":7},"535":{"A":[[0,-1,-1,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[0,1,-1,0,1,0,0,-1],[0,1,-1,0,-1,0,0,1]],"dim":7},"536":{"A":[[0,1,-1,0,1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,-1,1,0,0]],"dim":7},"537":{"A":[[0,-1,1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,-1,0,0,1]],"dim":7},"538":{"A":[[0,1,-1,0,-1,0,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[0,1,1,0,-1,0,0,-1],[0,1,-1,0,1,0,0,-1]],"dim":7},"539":{"A":[[1,0,1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,-1,0],[1,0,-1,0,-1,0,1,0]],"dim":7},"54":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,-1,1,0,0],[0,0,0,0,-1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,1,1,1,-1]],"dim":1},"540":{"A":[[-1,0,-1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,0,-1,0,-1,0,-1,0]],"dim":7},"541":{"A":[[1,0,1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,0,-1,0,1,0,1,0]],"dim":7},"542":{"A":[[-1,0,-1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,-1,0,1,0,-1,0]],"dim":7},"543":{"A":[[1,0,-1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0]],"dim":7},"544":{"A":[[-1,0,1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0]],"dim":7},"545":{"A":[[1,0,-1,0,-1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,1,0],[1,0,1,0,-1,0,-1,0]],"dim":7},"546":{"A":[[-1,0,1,0,1,0,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,0,1,0,-1,0,1,0]],"dim":7},"547":{"A":[[1,1,0,0,0,0,1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,-1]],"dim":7},"548":{"A":[[-1,-1,0,0,0,0,-1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,-1,0,0,0,0,1,1]],"dim":7},"549":{"A":[[1,1,0,0,0,0,-1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,-1]],"dim":7},"55":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,-1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,1,-1,1]],"dim":1},"550":{"A":[[-1,-1,0,0,0,0,1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,-1,0,0,0,0,-1,1]],"dim":7},"551":{"A":[[1,-1,0,0,0,0,1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,-1]],"dim":7},"552":{"A":[[-1,1,0,0,0,0,-1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,0,0,0,0,1,1]],"dim":7},"553":{"A":[[1,-1,0,0,0,0,-1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,-1]],"dim":7},"554":{"A":[[-1,1,0,0,0,0,1,1]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,0,0,-1,1]],"dim":7},"555":{"A":[[1,1,0,0,1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,-1,0,0]],"dim":7},"556":{"A":[[-1,-1,0,0,-1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,1,0,0,-1,1,0,0]],"dim":7},"557":{"A":[[1,1,0,0,-1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"558":{"A":[[-1,-1,0,0,1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"559":{"A":[[1,-1,0,0,1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"56":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,-1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,1,1,-1,-1]],"dim":1},"560":{"A":[[-1,1,0,0,-1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"561":{"A":[[1,-1,0,0,-1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"562":{"A":[[-1,1,0,0,1,1,0,0]],"B":[[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"563":{"A":[[1,0,1,0,0,1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"564":{"A":[[-1,0,-1,0,0,-1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"565":{"A":[[1,0,1,0,0,-1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"566":{"A":[[-1,0,-1,0,0,1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"567":{"A":[[1,0,-1,0,0,1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"568":{"A":[[-1,0,1,0,0,-1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"569":{"A":[[1,0,-1,0,0,-1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"57":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,-1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,-1,1,1]],"dim":1},"570":{"A":[[-1,0,1,0,0,1,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"571":{"A":[[0,1,1,0,0,1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"572":{"A":[[0,-1,-1,0,0,-1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"573":{"A":[[0,1,1,0,0,-1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0]],"dim":7},"574":{"A":[[0,1,-1,0,0,1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"575":{"A":[[0,1,-1,0,0,-1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"576":{"A":[[0,-1,1,0,0,1,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0]],"dim":7},"577":{"A":[[0,0,0,0,-1,-1,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"578":{"A":[[0,0,0,0,1,1,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"579":{"A":[[0,0,0,0,-1,-1,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0]],"dim":7},"58":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,-1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,1,-1,1,-1]],"dim":1},"580":{"A":[[0,0,0,0,1,-1,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0]],"dim":7},"581":{"A":[[0,0,0,0,-1,1,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0]],"dim":7},"582":{"A":[[0,0,0,0,1,-1,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"583":{"A":[[0,0,0,0,-1,1,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,2,0,0,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0]],"dim":7},"584":{"A":[[1,1,1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,1,-1,-1,0,0,0,0]],"dim":7},"585":{"A":[[-1,-1,-1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,-1,1,1,0,0,0,0]],"dim":7},"586":{"A":[[-1,-1,1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"587":{"A":[[1,-1,1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"588":{"A":[[-1,1,-1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,-1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"589":{"A":[[1,-1,-1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"59":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,-1,0,0,1]],"B":[[0,0,0,0,1,-1,-1,1]],"dim":1},"590":{"A":[[-1,1,1,1,0,0,0,0]],"B":[[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,-1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"591":{"A":[[-1,0,0,-1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"592":{"A":[[1,0,0,1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"593":{"A":[[-1,0,0,-1,1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"594":{"A":[[1,0,0,-1,1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,-1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"595":{"A":[[-1,0,0,1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,1,0,-1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"596":{"A":[[1,0,0,-1,-1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"597":{"A":[[-1,0,0,1,1,0,0,1]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"598":{"A":[[0,1,0,1,1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"599":{"A":[[0,-1,0,-1,-1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"6":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,0,2,0,0,0]],"dim":1},"60":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,1,0,0],[0,0,0,0,1,0,1,0],[0,0,0,0,1,0,0,1]],"B":[[0,0,0,0,1,-1,-1,-1]],"dim":1},"600":{"A":[[0,1,0,1,-1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"601":{"A":[[0,-1,0,-1,1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"602":{"A":[[0,1,0,-1,1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,1,1,0,0,0,0]],"dim":7},"603":{"A":[[0,-1,0,1,-1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"604":{"A":[[0,1,0,-1,-1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"605":{"A":[[0,-1,0,1,1,0,1,0]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,0,2,0,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,1,1,0,0,0,0]],"dim":7},"606":{"A":[[0,0,1,1,0,0,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"607":{"A":[[0,0,1,1,0,0,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"608":{"A":[[0,0,-1,-1,0,0,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,-1,0,0,0,0]],"dim":7},"609":{"A":[[0,0,1,-1,0,0,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,-1,0],[1,1,1,1,0,0,0,0]],"dim":7},"61":{"A":[[-1,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,1,1,0,0,0,0]],"dim":1},"610":{"A":[[0,0,-1,1,0,0,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,-1,0],[1,1,1,1,0,0,0,0]],"dim":7},"611":{"A":[[0,0,1,-1,0,0,-1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,-1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"612":{"A":[[0,0,-1,1,0,0,1,1]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,2,0,0],[0,1,1,0,1,0,0,1],[1,0,1,0,1,0,1,0],[1,1,1,1,0,0,0,0]],"dim":7},"613":{"A":[[0,0,1,1,1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"614":{"A":[[0,0,-1,-1,-1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"615":{"A":[[0,0,1,1,-1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"616":{"A":[[0,0,-1,-1,1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"617":{"A":[[0,0,1,-1,1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"618":{"A":[[0,0,-1,1,-1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,-1,0,0,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"619":{"A":[[0,0,1,-1,-1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"62":{"A":[[-1,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,1,-1,0,0,0,0]],"dim":1},"620":{"A":[[0,0,-1,1,1,1,0,0]],"B":[[2,0,0,0,0,0,0,0],[0,2,0,0,0,0,0,0],[0,0,0,0,0,0,2,0],[0,0,0,0,0,0,0,2],[0,1,1,0,1,0,0,1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"621":{"A":[[0,1,0,1,0,1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"622":{"A":[[0,-1,0,-1,0,-1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"623":{"A":[[0,1,0,1,0,-1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"624":{"A":[[0,-1,0,-1,0,1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"625":{"A":[[0,1,0,-1,0,1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"626":{"A":[[0,-1,0,1,0,-1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,1],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"627":{"A":[[0,1,0,-1,0,-1,0,1]],"B":[[2,0,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,2,0],[0,1,1,0,1,0,0,-1],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"628":{"A":[[1,0,0,1,0,1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"629":{"A":[[-1,0,0,-1,0,-1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"63":{"A":[[-1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,1,-1,-1,0,0,0,0]],"dim":1},"630":{"A":[[1,0,0,1,0,-1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"631":{"A":[[-1,0,0,-1,0,1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,-1,0,0,0,0]],"dim":7},"632":{"A":[[1,0,0,-1,0,1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"633":{"A":[[-1,0,0,1,0,-1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,1,0,0,1,-1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"634":{"A":[[1,0,0,-1,0,-1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,-1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"635":{"A":[[-1,0,0,1,0,1,1,0]],"B":[[0,2,0,0,0,0,0,0],[0,0,2,0,0,0,0,0],[0,0,0,0,2,0,0,0],[0,0,0,0,0,0,0,2],[1,0,1,0,1,0,1,0],[1,1,0,0,1,1,0,0],[1,1,1,1,0,0,0,0]],"dim":7},"64":{"A":[[1,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,1,1,0,0,0,0]],"dim":1},"65":{"A":[[1,1,0,0,0,0,0,0],[-1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,1,-1,0,0,0,0]],"dim":1},"66":{"A":[[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,-1,1,0,0,0,0]],"dim":1},"67":{"A":[[1,1,0,0,0,0,0,0],[1,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[1,-1,-1,-1,0,0,0,0]],"dim":1},"68":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,0,1,1,0,0,-1]],"dim":1},"69":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,0,1,-1,0,0,1]],"dim":1},"7":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,0,0,2,0,0]],"dim":1},"70":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[-1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,0,1,-1,0,0,-1]],"dim":1},"71":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,1,0,0,1]],"dim":1},"72":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[-1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,1,0,0,-1]],"dim":1},"73":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[-1,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,-1,0,0,1]],"dim":1},"74":{"A":[[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[1,0,0,1,0,0,0,0],[1,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[1,0,0,0,0,0,0,1]],"B":[[1,0,0,-1,-1,0,0,-1]],"dim":1},"75":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,1,1,0,1,0]],"dim":1},"76":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,1,1,0,-1,0]],"dim":1},"77":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,1,-1,0,1,0]],"dim":1},"78":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,1,-1,0,-1,0]],"dim":1},"79":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,-1,1,0,1,0]],"dim":1},"8":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,0,0,0,0,2,0]],"dim":1},"80":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,-1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,-1,1,0,-1,0]],"dim":1},"81":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,-1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,-1,-1,0,1,0]],"dim":1},"82":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,1,0,1,0,0,0,0],[0,1,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,1,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,1,0,-1,-1,0,-1,0]],"dim":1},"83":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,0,1,1,0,0,1,1]],"dim":1},"84":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,0,1,1,0,0,-1,1]],"dim":1},"85":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,0,1,1,0,0,-1,-1]],"dim":1},"86":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,0,1,-1,0,0,1,1]],"dim":1},"87":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,-1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,0,1,-1,0,0,1,-1]],"dim":1},"88":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,-1,0,0,0,0,1]],"B":[[0,0,1,-1,0,0,-1,1]],"dim":1},"89":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,1,0,0,0,1,0],[0,0,1,0,0,0,0,1]],"B":[[0,0,1,-1,0,0,-1,-1]],"dim":1},"9":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,0,0,0,0,1,0,0],[0,0,0,0,0,0,1,0]],"B":[[0,0,0,0,0,0,0,2]],"dim":1},"90":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,-1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,1,1,1,0,0]],"dim":1},"91":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,1,1,-1,0,0]],"dim":1},"92":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,-1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,1,-1,1,0,0]],"dim":1},"93":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,-1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,1,-1,-1,0,0]],"dim":1},"94":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,-1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,-1,1,1,0,0]],"dim":1},"95":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,-1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,-1,1,-1,0,0]],"dim":1},"96":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,-1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,-1,-1,1,0,0]],"dim":1},"97":{"A":[[1,0,0,0,0,0,0,0],[0,1,0,0,0,0,0,0],[0,0,1,1,0,0,0,0],[0,0,1,0,1,0,0,0],[0,0,1,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,0,0,0,0,0,0,1]],"B":[[0,0,1,-1,-1,-1,0,0]],"dim":1},"98":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,-1,0,0,0,0,0,1]],"B":[[0,1,0,1,0,1,0,1]],"dim":1},"99":{"A":[[1,0,0,0,0,0,0,0],[0,0,1,0,0,0,0,0],[0,-1,0,1,0,0,0,0],[0,0,0,0,1,0,0,0],[0,-1,0,0,0,1,0,0],[0,0,0,0,0,0,1,0],[0,1,0,0,0,0,0,1]],"B":[[0,1,0,1,0,1,0,-1]],"dim":1}}} \ No newline at end of file diff --git a/research/bit-completed-backend-api/independent/inputs/independent.py b/research/bit-completed-backend-api/independent/inputs/independent.py new file mode 100644 index 0000000000..498ebb37a3 --- /dev/null +++ b/research/bit-completed-backend-api/independent/inputs/independent.py @@ -0,0 +1,113 @@ +"""Independent tight tail/rank-compiler/bootstrap arithmetic successor. + +Uses the separately implemented PR4760 census and positive-series engine. +No primary price/tail/interval module is imported or called. +""" +from pathlib import Path +# Apache-2.0. Internal independent OpenAI Codex check for ai-nanachi. +from fractions import Fraction as F +from decimal import Decimal,localcontext +from hashlib import sha256 +import importlib.util,json,sys + +HERE=Path(__file__).resolve().parent;ROOT=HERE.parents[1] +PKG=HERE.parent/'bit-compact-productive-controller' +PRIMARY=HERE/'RESULT.json' +TESTED=F('.00347545806');UNIFORM=F('.00347545805') +ETA=F(1,2**39);V=1024;U=F(1,5);RHO=F(1,100) +COVER_GAP=F(1,2**36)+F(1,10**20);C1=UNIFORM-COVER_GAP +PRIME=2**45;B0=F('.0034597');OLD_EXACT=F(17713901828029,5120000000000000) + + +def need(v,m): + if not v:raise ValueError(m) + + +def ceil(x):return -((-x.numerator)//x.denominator) +def floor(x):return x.numerator//x.denominator + + +def decimal(x): + with localcontext() as c: + c.prec=60;return str(Decimal(x.numerator)/x.denominator) + + +def encode(x): + if isinstance(x,F):return str(x) + if isinstance(x,dict):return {str(k):encode(v) for k,v in x.items()} + if isinstance(x,(list,tuple)):return [encode(v) for v in x] + return x + + +def main(): + ipath=PKG/'independent_price.py' + spec=importlib.util.spec_from_file_location('separate_PR4760_tight_census',ipath);I=importlib.util.module_from_spec(spec);spec.loader.exec_module(I) + T,P,local,helpers,baseline=I.census();X=I.X + need(sum(T.values())==11400 and sum(P.values())==57339 and helpers=={4:4,8:432},'unchanged actual productive unit') + t=1-TESTED;target=X.moment(T,t);paid=X.moment(P,t) + alpha=X.div(paid,target) + gamma=X.div(X.moment(P,t+U),X.mul(X.power(17,U),target)) + delta=X.div((F(sum(T.values())*18),)*2,X.mul(X.power(17,TESTED),target)) + need(alpha[1]<1-ETA,'tight strict raw alpha gap') + need(gamma[1]0,'alpha Bernoulli bound plus both tails strictly contracts') + h=F(1,64);z=1-UNIFORM;z0=(t+z)/2;g=z0-t + overhead=(5+8*h)*V;debt=1+8*V*(1-z0) + H0=ceil((g*overhead+debt)/(h*g));H1=floor(H0*(1-z0)/(z-z0))+1 + need(g>0 and H0>=8*V and H0*h*g>=g*overhead+debt,'new effective compiler induction') + need(H1*(z-z0)>H0*(1-z0),'new uniform rank bound') + need(17**64<18**63 and max(T)<256,'strict completed rank separation') + need(F(PRIME)>256/COVER_GAP,'complete delayed-cover fallback prime budget') + previous=B0;levels=[] + for level in range(1,4): + exact=(1-RHO)*C1+RHO*previous;admitted=F(floor(exact*10**10),10**10) + if exact==admitted:admitted-=F(1,10**10) + row=dict(level=level,backend_level=level-1,completed_backend_saving=previous,ordinary_exact=exact,ordinary_exact_decimal=decimal(exact),admitted=admitted,admitted_decimal=decimal(admitted),adapter_gap=RHO-exact,stock_gap=1-exact-RHO,ordinary_relaxation_gap=exact-admitted,improvement_gap=admitted-previous) + need(all(row[k]>0 for k in('adapter_gap','stock_gap','ordinary_relaxation_gap','improvement_gap')),'all finite ordinary stage gaps') + need((1-RHO)*(1-C1)+RHO*(1-previous)==1-exact,'actual ordinary body exponent') + levels.append(row);previous=admitted + need(previous==F(1737729,500000000),'independently derived final finegrid saving') + # Only now read and compare the primary table, including every level's tail. + primary=json.loads(PRIMARY.read_bytes()) + need(F(primary['C1'])==C1 and primary['new_H0']==H0 and primary['new_H1']==H1,'primary newrank constants agree') + shared={'tested':TESTED,'uniform':UNIFORM,'cover_gap':COVER_GAP,'atom':RHO,'alpha_gap':ETA,'prime_coefficient':F(PRIME)} + need(all(F(primary['params_shared'][k])==v for k,v in shared.items()),'all primary shared parameters') + need(len(primary['levels'])==3,'three completed finite levels') + for computed,root in zip(levels,primary['levels']): + for k in('level','completed_backend_saving','ordinary_exact','admitted'): + need(F(root[k])==computed[k],'independent stage agreement '+k) + cert=root['certificate'];tail=cert['tail'];need(tail['compiler_H0']==H0 and tail['uniform_H1']==H1,'all levels use the newcompiler bounds') + need(all(F(cert['params'][k])==v for k,v in shared.items()),'all per-level shared parameters') + need(F(cert['params']['old_backend'])==computed['completed_backend_saving'] and F(cert['params']['admitted'])==computed['admitted'],'actual predecessor/admission at each level') + need(F(cert['after_cover'])==C1 and F(cert['ordinary_exact'])==computed['ordinary_exact'] and F(cert['admitted'])==computed['admitted'],'nested certificate exact values') + need(F(tail['tested_saving'])==TESTED and F(tail['uniform_saving'])==UNIFORM and tail['tensor_power']==V and tail['cutoff_base']==17 and tail['target_floor_base']==18 and F(tail['tail_exponent'])==U,'entire tail and cutoff parameters') + need(F(tail['normalized_surplus_lower'])==surplus,'primary strict tail surplus') + for name,bounds in [('alpha',alpha),('gamma',gamma),('delta',delta)]: + display=tail[name] + need(F(display['lower'])<=bounds[0]<=bounds[1]<=F(display['upper']),'independent series enclosure contained in primary '+name) + margins=cert['margins'] + need(F(margins['adapter'])==computed['adapter_gap'] and F(margins['stock'])==computed['stock_gap'] and F(margins['ordinary_relaxation'])==computed['ordinary_relaxation_gap'],'all stage margins agree') + need(F(margins['prime_allowance'])==F(PRIME)-256/COVER_GAP,'all per-stage full prime allowances') + gain=previous/OLD_EXACT-1 + need(F(primary['relative_gain_over_previous_exact'])==gain,'comparison against actual previous exact') + controls={} + def reject(label,condition): + need(not condition,'bad control unexpectedlypasses '+label);controls[label]='REJECT' + reject('old_alpha_gap_2^-32',alpha[1]<1-F(1,2**32)) + reject('weaker_alpha_gap_2^-40_same_tailbudget',1-1/(1+V*F(1,2**40))-F(4,2**32)>0) + reject('old_H0',377227157504*h*g>=g*overhead+debt) + reject('old_H1',262206447682297857*(z-z0)>H0*(1-z0)) + reject('old_atom_00346',F('.00346')>levels[-1]['ordinary_exact']) + reject('closed_covered_limit',levels[-1]['ordinary_exact']>C1) + reject('unfunded_prime_2^36',F(2**36)>256/COVER_GAP) + rawlo=F('.003475458064076428997514');rawhi=F('.003475458064076428997515') + result=dict(status='PASS_INDEPENDENT_TIGHT_TAIL_NEW_COMPILER_AND_THREE_FINITE_LEVELS',targets=T,paid=P,local=local,helpers=helpers,tested=TESTED,uniform=UNIFORM,t=t,alpha_gap=ETA,alpha=alpha,gamma=gamma,delta=delta,tail_surplus=surplus,compiler_H0=H0,uniform_H1=H1,uniform_N_symbolic='2^'+str(H1),cover_gap=COVER_GAP,C1=C1,prime_coefficient=PRIME,prime_allowance_margin=F(PRIME)-256/COVER_GAP,levels=levels,admitted=previous,relative_gain_over_PR4760_exact=gain,percent_gain_over_PR4760_exact=decimal(100*gain),raw_crossing_minus_admitted=[rawlo-previous,rawhi-previous],negative_controls=controls,primary_price_imported=False,actual_backend_API_independently_verified=False,new_WORD=False,new_whole_kappa=False,sourcepins={p.relative_to(ROOT).as_posix():sha256(p.read_bytes()).hexdigest() for p in(ipath,PKG/'exact_series.py',PKG/'SOURCES.json',PRIMARY)},scope='Same rawSOURCE unit; new tested/uniform exponents require NEW compiled rankN,q/ROW/height/tape/stock constants. Numeric finite stages only; actual completebackend API/algorithm freezing remains under same sourcebridge conditional framework. No infinite-limit or materialized uniformWORD claim.') + encoded=encode(result);target=HERE/'INDEPENDENT.json' + if '--write'in sys.argv:target.write_bytes((json.dumps(encoded,sort_keys=True,indent=2)+'\n').encode()) + else:need(encoded==json.loads(target.read_bytes()),'Deterministic independent certificate') + print(json.dumps(dict(status=result['status'],H0=H0,H1=H1,tail_surplus=str(surplus),separators=[r['admitted_decimal'] for r in levels],percent_gain=result['percent_gain_over_PR4760_exact'],controls=len(controls)))) + + +if __name__=='__main__':main() diff --git a/research/bit-completed-backend-api/independent/inputs/three-stage-cover-bit.tex b/research/bit-completed-backend-api/independent/inputs/three-stage-cover-bit.tex new file mode 100644 index 0000000000..f05225d21f --- /dev/null +++ b/research/bit-completed-backend-api/independent/inputs/three-stage-cover-bit.tex @@ -0,0 +1,264 @@ +\subsection{Atom contract and common endpoint} +Fix an odd prime $q$, chosen below, and put $R_w=\mathbb Z/q^w\mathbb Z$. +An atom is a complete consecutive $w$-digit address field. Write $C_n$ for +reversal of the $n$ atom positions, without reversing digits inside an atom. +The recursive contract is the involution +\[ + F_A(H,D)=(AC_nD,C_nA^{-1}H), +\] +where $A$ is a diagonal array of units on the head atoms. Its entries may +depend on exposed ancestor row fields and the atom index, but not on the +fresh role fields of this invocation or on the head/data values. Only the +polynomial-time descriptors generated by the construction are required; +no constant-cost oracle for arbitrary functions of a prefix is assumed. +Every call preserves all complete spectator fields and restores its row +coordinate. The original unweighted call has $A=I$. + +For a split idempotent $P$ on the head coordinates set +\[ + D_P=\begin{pmatrix}I-P&PC_n\\C_nP&I-C_nPC_n\end{pmatrix}, + \qquad F=D_I. +\] +These are involutions, and $D_P-I$ has split rank $\operatorname{rank}P$. +Nested commuting-projector identities are polynomial identities and require +no symmetry of $P$. For $n=mf$ and $G=g\otimes I_f$ define +\[ + Q_g=\operatorname{diag}(G,C_nGC_n). +\] +Then $Q_gF=FQ_g$ and $Q_gD_PQ_g^{-1}=D_{GPG^{-1}}$. +Consequently conjugating every base frame by any $g\in\operatorname{GL}_m(R_w)$ +leaves the same full physical endpoint $F$. + +Put $Q_A=\operatorname{diag}(A,I)$. Conjugate the entire completed scalar +word by $Q_A$. Scalar gates mix roles having the same address map, so they +commute with $Q_A$. A current role routing also commutes with $Q_A$, since +it changes only fresh fields. Thus only address residuals change, and the +completed endpoint is $Q_AFQ_A^{-1}=F_A$. More explicitly, when a port +changes charts from $g$ to $gR_s$, its local label changes from $M$ to +$R_s^{-1}MR_s$, and +\[ + (gR_s)(R_s^{-1}MR_s)(gR_s)^{-1}=gMg^{-1}. +\] +This routing is a change of row/chart, not an uncharged dense address map. +The adapted chart $Q_AQ_gQ_A^{-1}$ commutes with $F_A$. None of these +conjugations is executed as an extra normalization pass. + +\subsection{Explicit rational three-stage geometry} +Use the retained PR97 local producer with +\[ + h=23,\qquad v=1771,\qquad R_{\rm loc}=28866,\qquad \ell=506. +\] +Its physical projector ranks and scalar word are unchanged. On +$\mathcal A=\mathbb Q^{23}$ take the form $H_0=(I-J/9)/2$. +For a triple $S$ let $q_S=\chi_S$; then $q_S^tH_0q_S=1$. +Fix $q_0=\chi_{\{1,2,3\}}$ and $K=q_0^\perp$. A rational basis is +\[ + k_i=e_i-(e_i^tH_0q_0)q_0,\qquad 2\le i\le23. +\] +Projection along $q_0$ is injective on the span of $e_2,\ldots,e_{23}$, +since $q_0$ has nonzero first coordinate. Thus this is indeed a basis. +Let $\mathcal B,\mathcal C$ be orthogonal copies of $K$ and put +$\mathcal E=\mathcal A\perp\mathcal B\perp\mathcal C$, of dimension $m=67$. + +Choose a coordinate permutation $\pi_S$ taking $\{1,2,3\}$ to $S$. +It preserves $H_0$. The rational isometry $R_{12,S}$ fixes $q_S$ and +$\mathcal C$, and exchanges $\pi_Sk_i\in q_S^\perp\subset\mathcal A$ +with $k_i\in\mathcal B$. Define $R_{23,S}$ by exchanging the same vectors +with their copies in $\mathcal C$, fixing $q_S$ and $\mathcal B$. +Both maps are involutions. A hyperedge $(g,S)$ uses the invocations +$gR_{12,S},g,gR_{23,S}$, with active spaces +\[ + g(\mathcal B+\mathbb Qq_S),\qquad g\mathcal A, + \qquad g(\mathcal C+\mathbb Qq_S). +\] +Their projectors commute; their pairwise and common intersection is the +projector $P_{gq_S}$, and their sum is $I+2P_{gq_S}$. +This follows from the orthogonal decomposition +$\mathbb Qq_S\perp q_S^\perp\perp\mathcal B\perp\mathcal C$ before +conjugation. These are the cumulative-projector three-stage transfer +identities: the three scalar shears complete the interchange, with zero +interstage connectors and no rank-one endpoint correction. Each port +family visits the full cover bijectively, by right multiplication with +its displayed involution. The physical ledger is therefore three copies +of the local auxiliary, data and center histograms, and three copies of +the exterior histogram $m-\text{nullity}$. + +\subsection{One weighted child on a generic residue class} +Work first on one atom column. Let $g$ be its weighted residual involution, +of split rank $r$ relative to $I$. If the cross block has generic northeast +rank profile, unit lower row and column elimination, without normalizing +pivots, gives +\[ + Lg_{XY}R=ED_pF_0^t, + \quad E=(e_1,\ldots,e_r),\quad + F_0=(e_m,\ldots,e_{m-r+1}), +\] +with invertible diagonal $D_p$. Conjugate by $\operatorname{diag}(L,R^{-1})$. +Split rank and the unit pivot minor give a factorization +\[ + g-I=\binom EB(A_0,D_pF_0^t),\qquad + A_0E+D_pF_0^tB=-2I_r. +\] +For clarity, if $g-I=UV$, then $g^2=I$ gives +$U(VU+2I)V=0$. The unit minor supplies a left inverse of $U$ and a right +inverse of $V$, proving the identity over the local ring itself. +Set +\[ + K=-(B+F_0D_p^{-1})E^t+F_0D_p^{-1}A_0(I-EE^t), + \qquad S=\begin{pmatrix}I&0\\K&I\end{pmatrix}. +\] +The identities $KE=-B-F_0D_p^{-1}$ and +$D_pF_0^tK=A_0+E^t$ give +\[ + SgS^{-1}=\begin{pmatrix} + I-EE^t&ED_pF_0^t\\F_0D_p^{-1}E^t&I-F_0F_0^t + \end{pmatrix}. +\] +This is one weighted reversed interchange on the first $r$ head and last +$r$ tail coordinates. All other factors are unit lower intrabank maps or +lower cross-bank additive maps. Thus variable diagonal units remain in +the child's weight array rather than becoming unsupported routing passes. + +For $n=mf$, group atoms by coarse coordinate $i$ and column $j$. +If $L_P,R_P,D_P$ are unweighted normalizers for the current projector and +$A_j=\operatorname{diag}(A[if+j])$, then +$L_j=A_jL_PA_j^{-1}$ and $R_j=R_P$ are unit lower normalizers for +$A_jPC_m$. The child's exact contiguous index rule is +\[ + A_{\rm child}[kf+j]=A[i_kf+j]D_P[k]. +\] +The cross-bank atom pairing is reversed, and $C_r\otimes C_f=C_{rf}$. +Hence the middle operation is exactly one $rf$-atom call of the same +contract, with no interleaving or gathering. Its coefficients depend only +on parent prefix fields, which become ancestor spectators at the child; +the child's fresh roles come from disjoint unused row stock. + +All unit lower adapters require $O(n)$ atom passes. The retained ordered +affine lemma implements each later-target shear in $O(V)$, including +prefix-controlled offsets. The generated descriptors have polynomial cost +in $w$: good-class evaluation follows one ancestral index per level; +fallback evaluation branches by a constant per level. Since depth is +$O(\log e)$ and $w=\lceil e^{1/1000}\rceil$, this costs $e^{O(1)}=w^{O(1)}$. +Stored ancestor data use $O(w\log e)$ bits. The proof of the ordered affine +lemma still applies with these controls: polynomial preparation per prefix +is absorbed by the complete $q^w$ target fiber. Unrelated spectator counters +are incremented by ripple counting rather than read in their entirety. + +\subsection{Weighted leaves and a genuine local-ring fallback} +At one atom write $J_a=\left(\begin{smallmatrix}0&a\\a^{-1}&0\end{smallmatrix}\right)$, +$U(a)=\left(\begin{smallmatrix}1&a\\0&1\end{smallmatrix}\right)$ and +$L(b)=\left(\begin{smallmatrix}1&0\\b&1\end{smallmatrix}\right)$. +Then +\[ + J_a=\operatorname{diag}(1,-1)U(a)L(-a^{-1})U(a), + \qquad U(a)=J_1L(a)J_1. +\] +Thus a weighted leaf uses four old ordinary atom interchanges, three +prefix-controlled shifts and one fixed sign. With +$a_{\rm old}=384599/10^{10}$ it costs $O(Vw^{1-a_{\rm old}})$. +This constant occurs only at stopped leaves. + +A bad residue class cannot be treated by field Bruhat elimination: +an entry zero modulo $q$ need not vanish modulo $q^w$. Instead Gaussian +eliminate the full invertible residual of size $N_0=2m$ with unit pivots. +Each invertible Schur complement has a unit in its next pivot column; +row swaps and unnormalized additions clear that column. There are at most +$N_0(N_0-1)$ additions and $N_0$ swaps. Pivot choices are determined by +the unweighted low residue class: diagonal conjugation scales every +Schur-complement row and column by units and preserves its zero pattern. +The final diagonal has product a fixed sign, since the residual has +determinant $(-1)^r$ and row swaps change only the sign. + +A lower addition is a paid additive adapter. An upper addition is +conjugated into a lower addition by two ordinary coarse-field swaps. +For a field of $f$ atoms, let $R_{\rm tail}$ reverse the later field. +Then the ordinary weighted swap is +\[ + J_A=R_{\rm tail}F_AR_{\rm tail},\qquad + J_A(H,D)=(AD,A^{-1}H). +\] +Each $R_{\rm tail}$ is one unweighted reversed call on the first and last +$\lfloor f/2\rfloor$ atoms, fixing a possible middle atom. Thus $J_A$ +costs at most three children of widths $f,\lfloor f/2\rfloor, +\lfloor f/2\rfloor$. A paired diagonal scaling is $J_aJ_1$, at most six +children. The full diagonal is a product of $N_0-1$ such pairs and a fixed +sign. Across the two banks the reversed pairing already makes the swaps +and diagonal pairs directly reversed calls; the preceding ordinary bounds +remain conservative. Reindexing a tail weight by $j\mapsto f-1-j$ changes +only its descriptor. Charging every addition as upper therefore gives +\[ + 6N_0(N_0-1)+3N_0+6(N_0-1)<32m^2. +\] +Every child has width at most $f$, hence ratio at most $1/m$. Coefficients +are computed from constant-sized local-ring matrices and parent weight +descriptors; only units are inverted. This proves the fallback cost, +including its actual reversals, rather than assuming nonunit pivots away. + +\subsection{Finite covers, batching, and the strict moment} +Take $q>2^{80}$ avoiding all fixed rational denominators and rank witnesses. +At atom width $w$ use the finite cover $\operatorname{GL}_m(R_w)$ and its +right-multiplication edges $g\mapsto gR_s$. Every vertex has the unique chart +\[ + g=g_0+qG_1,\quad g_0\in\operatorname{GL}_m(\mathbb F_q), + \quad G_1\in(\mathbb Z/q^{w-1}\mathbb Z)^{m^2}, +\] +using fixed representatives for $g_0$. Right multiplication permutes $g_0$ +and acts affinely on $G_1$, with a carry determined by $g_0$. Its fixed +dimensional rational linear part factors into fixed scalings, ordered +shifts and a constant number of old width-$O(w)$ interchanges. Thus each +fixed port routing costs $O(Vw^{1-a_{\rm old}})$. + +Let $W_0=|\operatorname{GL}_m(\mathbb F_q)|(2v+3R_{\rm loc})$. +The full role count is $W(w)=W_0q^{m^2(w-1)}$. Split preceding rows into +low role type, high matrix and unused stock. Batch \emph{all} high matrices +for each low type in one stream. A frame edge is one child on this whole +batch, of volume $V/W_0$, and routing is executed once per fixed operation +type. Consequently neither the number of tapes nor the number of child +programs grows with $w$. High cardinality cancels in the normalized moment, +but its $m^2(w-1)$ digits are charged in the row reserve. + +For each fixed projector require the leading minors of sizes $1$ through +$r$ to be units. Each cleared minor polynomial in $g_0$ is nonzero: +similarity to $\operatorname{diag}(I_r,0)$ supplies a witness after the +fixed rank is preserved modulo $q$. Their total degree is at most $m^3$. +The polynomial zero bound and conditioning on invertibility (a factor at +most two) give bad fraction at most $2m^3/q<10^{-16}$ for each edge type. +No simultaneous union bound over edge types is needed, since their moments +are averaged separately. Good classes use the whole-rank child; bad +classes use the full $32m^2$-child fallback just proved. + +Let $H_r$ be the three-stage histogram described above and +$W=2v+3R_{\rm loc}=90140$. The retained ledger gives +\[ + \sum_r rH_r=6037356,\qquad Wm-\sum_r rH_r=2024=2v-3\ell, + \qquad \max\{r:H_r>0\}=66. +\] +For $a=747/2000000$, $\tau=1-a$, and $b=10^{-16}$ the conservative moment is +\[ + \mu_\tau\le + \sum_r\frac{H_r}{W}(r/m)^\tau+ + b\frac{32m^2\sum_rH_r}{W}(1/m)^\tau<1. +\] +The entire fallback is added; no displaced good contribution is subtracted. +The exact script \path{scripts/three_stage_cover_network.py} and certificate +\path{certificates/three-stage-cover-network.json}, from the retained axis +\path{certificates/three-stage-cover-bit-input.json}, give +$1-\mu_\tau>6.3397366396\cdot10^{-7}$. +The certificate uses the 32-term positive atanh logarithm series with its +geometric tail, $\exp(u)\le1+u+u^2/(2(1-u/3))$, and upward rounding to +the grid $2^{-120}$. All inputs have $0\le u<3$; these are rational upper +bounds, not floating-point root estimates. Since every child ratio is at +most one and $\tau<1$, this same strict bound implies $\mu_1<1$. + +With $T(n,w)$ denoting time divided by logical volume, the fixed low-type +profile $\{c_r\}$, including fallback classes, satisfies +\[ + T(n,w)\le\sum_rc_rT(r\lfloor n/m\rfloor,w)+Cn+Cw^{1-a_{\rm old}} + \quad(n\ge m),\qquad + T(n,w)\le Cw^{1-a_{\rm old}}\quad(na_{\rm bit}$ and $\beta<1-a_{\rm bit}$ make both +the atom-adapter and borrowing terms lower order. The remainder cost +$O(Vw^{1-a_{\rm old}})$ is also covered. Thus the ordinary radix-$q$ +interchange has cost $O(Ve^{1-a_{\rm bit}})$, without an externally supplied +superpolynomial stock of rows. + +For an original binary chunk range $[2^e]$, let +$t=\lceil e/\log_2q\rceil$ and embed it numerically into $[q^t]$. +Pad both exchanged ranges while retaining every spectator. The total +logical-volume increase is below $q^2$. Execute the completed ordinary +radix-$q$ interchange, then remove the padding. Its endpoint preserves the +rectangular genuine set $[2^e]\times[2^e]$; intermediate maps may mix genuine +and padded addresses, which does not affect this endpoint justification. +As $q$ is fixed and $t=\Theta(e)$, the binary interchange has the same +saving exponent. All schedules use a fixed number of finite-alphabet +tapes; low residue tables and port types are fixed independently of $w$. + +The conclusion retains the original local-producer, ordered-affine, +ordinary-leaf and multiplication-framework hypotheses. It adds no free +unit-scaling, dense chart transformation, or external row-stock primitive. diff --git a/research/bit-completed-backend-api/proposal/CLAIM-DRAFT.md b/research/bit-completed-backend-api/proposal/CLAIM-DRAFT.md new file mode 100644 index 0000000000..4bb01946cd --- /dev/null +++ b/research/bit-completed-backend-api/proposal/CLAIM-DRAFT.md @@ -0,0 +1,51 @@ +## CLAIM — one completed ordinary backend boundary in #4814 + +I am taking one independent verification of the first completed backend call +boundary, A0 (#4760) → A1 (#4814). This refines the `supplier-boundary-audit` +card from its historical #4088 dispatch example to the current ordinary BIT +interface. It does not rerun #4088 or claim a new native word. + +Canonical base: `cef4b52f2a59009865bf8eabde1be3f159063703`, priority revision 7. +Frozen sources: #4760 at `ecdfcabd56dfa663ae020733f9f1a88c6644743c` and #4814 +at `f56ae4533a7d97d782a2c596a33fe844cd051747`. The missing coverage is explicit +in #4814's independent checker: +`actual_backend_API_independently_verified=False`. Archive status and exact +arithmetic are separate from this interface proof. + +The scope is actual helper 462, frame 506, and its rank-four whole-job matcher +at column multiplicities 1 and 2: paired head and reversed-tail maps, two +independent nested ROW levels, complete spectators, ancestor-only external +weights, distinct-radix padding and the actual completed ordinary wrapper. +Every paid matcher route, weighted-leaf interchange, high-part operation, +stock operation, COPY/erasure and fallback remains charged. + +The deliverable is a source-bound all-width interface proof or a precise +missing implication, with at most 64 small discriminating matrix/state +fixtures. There will be no GL-group census, astronomical template +materialization or price retuning. I will stop after this one edge at a +counterexample, unresolved operation or unpriced route/padding charge. + +The test can validate or block the API premise behind conditional ordinary +BIT saving 0.003475458 versus the prior admitted 0.0034. It does not select a +frontier, discharge the inherited native/compiler/tape/analytic premises or +close the complex bottleneck. No new κ is claimed. Separate #4940 work +remains the primary construction. + +The root monitor's 03:06 UTC bounded comments/Discussions check found no exact +bridge owner; that does not exclude unpublished work. Credit ai-nanachi's +#4760/#4814; rohanarun's #185/#199 and Maxime Fleury's #204; Cinna Davis, zxv +and Jacob Alan Sussman; Mark/Matarener's #4697/#4612; and the retained source +lineage. Substantial OpenAI Codex assistance. The local proposal is not yet +publicly reproducible or independently reviewed. + +```json +{ + "schema": "integer-mult-coordination/v1", + "kind": "CLAIM", + "task": "supplier-boundary-audit", + "scope": "One #4814 first completed backend A0-to-A1 API bridge: actual helper 462/frame 506, f=1/2, two ROW levels, paid routes and spectator/radix restoration; no new supplier or kappa", + "base": "cef4b52f2a59009865bf8eabde1be3f159063703", + "expiry": "2026-10-23T05:15:00+00:00", + "artifact": null +} +``` diff --git a/research/bit-completed-backend-api/proposal/EXPERIMENT-PROPOSAL.md b/research/bit-completed-backend-api/proposal/EXPERIMENT-PROPOSAL.md new file mode 100644 index 0000000000..5d1a8e9f0f --- /dev/null +++ b/research/bit-completed-backend-api/proposal/EXPERIMENT-PROPOSAL.md @@ -0,0 +1,182 @@ +# One completed ordinary backend API gate:4760 A0 to4814 A1 + +PROPOSAL ONLY. No checker/emitter, native word, experimental receipt or public +post has been produced. Wait for the prospective claim to be visibly live +before executing this bounded test. The separate4940 physical work remains +the primary construction; this is a secondary ordinary-component audit. + +## Exact task, source and downstream decision + +Canonical main was independently confirmed by `git ls-remote` as +cef4b52f2a59009865bf8eabde1be3f159063703, priority revision7. The original +card is `supplier-boundary-audit` in `adversarial-audit`, whose exact question +is “Can the #4088 four-provider dispatch satisfy the complete ordinary/outer +admission contract?” TASK-PROPOSAL.json retains that complete unedited card. +Explicit donor assignment refines its historical provider to one current +completed-backend admission predicate. It does not claim that the catalogue +itself assigns4814 or that this audits4088/4100. + +Family: ordinary BIT / completed finite backend composition. +Canonical refined question: Does4760's completed ordinary A0 supply the +arbitrary-width, complete-spectator, restored-ROW, cross-radix and paid-routing +contract needed at4814's FIRST A1 ordinary call boundary? + +Freeze4760 ecdfcabd56dfa663ae020733f9f1a88c6644743c and4814 +f56ae4533a7d97d782a2c596a33fe844cd051747. The exact source locations and SHA256 +pins are in SOURCES.json. Historical185/199/204 supply credited finite +bootstrap composition; they are not new constructions here. Open4612 stock +formulas are predecessor coverage, not this new source-bound API proof. + +4814's arithmetic certificate is already strong: all paid completion/splitting, +cover/prime and three acyclic stage gaps pass author-side independent engines. +Its independent.py nevertheless explicitly sets +`actual_backend_API_independently_verified=False`. This experiment targets +that named missing coverage. A positive source-bound proof could validate +that interface for the conditional ordinary.003475458 improvement over the +previous admitted.0034. It cannot promote global kappa or independently prove +the retained native/compiler/tape/analytic primitives. A concrete source type +mismatch would stop use of the claimed composition until repaired. + +## Frozen arbitrary-input contract + +Fix the finite uniform supplier, its N,B,prime q, route/matrix list, owner +assignment and machine constants BEFORE the varying input chunk width e. +For all sufficiently large e, w=ceil(e^.01), and all arbitrary independent +original arrays with complete preceding and intervening spectators, A0 must +return the ordinary interchange of its two entire argument chunks, preserving +every spectator and restoring all externally visible ROW coordinates. Its +own stock must be borrowed from its own argument chunks and restored before +return; it is not new externally supplied zero space. Small widths use the +already completed bounded fallback, with a separately fixed threshold. + +The first fixture is the ACTUAL helper462, input frame0, output frame506, +rank4 inside the8-coordinate local head. Use its pinned B/A basis; construct +P=B^T(BB^T)^-1B and S=[B^T|A^T]. The source requires SQ4S^-1=P, +Q4=diag(I4,0). The source matcher law for paired heads/tails is +Q_S=diag(S,C8 S C8). At f=1 and2 use P tensor I_f, S tensor I_f and the +ACTUAL reversed-tail C_(8f)=C8 tensor C_f. Whole-job matching changes the +COMPLETE cover row g to gS and returns it by S^-1, depending on route +convention; the direction must be derived from the request/target equation, +not copied from an ambiguous gather notation. No dense map on an uncovered +ARRAY is free. The role has arbitrary original data and remains one rank4 +job; there is no rank8 promotion or extra helper reward. + +Use two independent ROW levels r_outer,r_inner and a preceding complete +spectator z. Top-level external weight may depend on a genuine preceding +ancestor a but not the outer fresh cover row. A child's pivot/weight may +depend on the exposed outer row, now an ancestor, but not its own fresh +inner row or fresh roles. Inner operations must keep r_outer,z fixed and +restore r_inner. Externally supplied ROW space is not multiplied by inner +stock. This must be shown by an exact typed chronological state proof. + +Small cross-radix fixture: outer radix5 and inner radix7, independently fixed, with +local-ring witnesses modulo25 and49 when the exact source matcher is +invertible there. These small primes are ONLY discriminating route/padding +fixtures; they do not satisfy or replace4814's actual large-prime rule. The +universal type proof must apply to every valid fixed source prime, including +the actual q>2^45 N^5. Likewise f1/f2 local blocks sit in identity spectator +axes; they do not materialize4814's enormous ambient N. If a denominator/ +determinant fails one fixture prime, STOP and +report the domain mismatch; do not search primes or silently change fixtures. +The ordinary argument ranges are numerically padded to binary complete +ranges and unpadded only at a completed ordinary endpoint. Charge initialization, +retention, routing and removal of padded rows. No arbitrary borrowed input is +assumed zero. The two exchanged range factors are each<2 (combined<4); +row-divisibility padding is a separate<2 factor. Endpoint invariance of the +genuine rectangular range must be proved even if intermediate states enter +padding. A matrix embedding alone does not establish this padding API. + +## One bounded experiment, with universal proof first + +1. Independently reconstruct helper462's exact rational P,S and paired + transport from the pinned source basis, not by importing helper_matchers. + Prove their generic tensor/reversal identities for all positive f. +2. Prove whole-cover right multiplication by S is a bijection and that a + common ancestor-only weight commutes with this route. Show that the + inner completed call restores both visible ROW levels pointwise. +3. Trace the actual completed ordinary body sequence + D-=H; F_n; D+=H; F_n; D=H-D on arbitrary symbolic data/spectators, using + F_n(H,D)=(C_n D,C_n H). Include high-part exchange and the four ordinary + atom interchanges used by each weighted leaf. Then prove the numeric + padding/unpadding boundary for distinct radices, rather than presuming it. +4. Implement only the discriminating small fixtures: f in{1,2}, the two + declared local rings, two fixed unipotent/identity cover representatives, + two nonconstant ancestor-weight assignments and two ROW nesting orders. + Maximum64 matrix/typed-state fixtures, no GL8/GL16 enumeration, no random + seeds, no rank profile or parameter search. Finite fixtures corroborate + the written universal identities; they cannot replace them. +5. After that first edge is proved, use the named acyclic A0,A1,A2,A3 types + for the finite three-level induction and independently check the EXISTING + strict parameter inequalities. Do not retune digits or invent A4. + +The two ROW nesting orders exercise separate return discipline; this is not +permission to commute chronological source calls. The checked positive case +must use the actual required order. The other ordering is either a valid +separate exact type fixture or a recorded rejecting control. + +Suggested controls: omit either matcher route; use an unpaired tail reversal; +let top weight depend on its fresh outer row; let child weight depend on its +fresh inner row; overwrite/alias the outer ROW with inner stock; use a raw +reversed body instead of the completed wrapper; remove numeric padding +cleanup; remove one of the four ordinary weighted-leaf calls. Rejections must +come from actual endpoint/ownership/type discrepancies, not tautological +copies of the intended equality (4612 already flags such prior checks). + +## Complete proposed paid-routing ledger and status + +No costs are removed. The test must bind this ledger; an unbound item is a +remaining obligation, never zero. Counts after astronomical uniform compilation +may be symbolic constructive bounds from the frozen finite compiler; no +materialization is proposed. + +| Component | Count/domain | Charge and current status | +|---|---|---| +| Native raw supplier |11400 original fields,57339 paid queries|Existing4760 profile, inherited source certificate; no changed invoice| +| Partial-helper matchers |2 routes for selected job;144 additional routes across72 partial outputs|Both forward/return whole-cover routes paid; source-bound direction under test| +| Other raw routes |7548 nonidentity main routes;7692 total with partial matchers|Inherited raw count, not the final compiled route count| +| Fixed compiled route |Every right multiplication and inverse in the finite final word|Low-type permutation, affine high-row map/carry, scalings/shifts and ordinary A0 calls; O(V w^(1-b0)) per fixed route, constructive finite multiplier must be traced| +| Weighted rank1 leaf |4 ordinary atom interchanges+3 controlled shifts+1 fixed sign per leaf|Retain all4, each ordinary call uses completed A0 with spectators/ROW; bound O(V w^(1-b0))| +| Bad-class fallback |Actual per-leaf source bounds, including up to32N^2 children|Paid with q>2^45 N^5 and d=2^-36+10^-20; do not drop exceptional rows| +| Completed body |2 completed F_n calls+3 additive maps|Fixed outer multiplicity, source restoration must allow reserve reuse; linear adapter O(Ve^(1-rho))| +| High-part exchange |One completed width-k exchange, k=O(w log e)|Its own inner borrowing included; O(V k^(1-b0))<=O(Vw log e)| +| Row and radix padding |Separate row<2, two-range<4, fixed finite nesting|New padded storage/initialization/unpadding paid; no per-coarse-level padding multiplier| +| Owned COPY/ERASE |All source local9 COPY episodes and final lifetime ledger|Existing rank7 charges retained; no new productive owner or free dirty reset| +| Scalar/machine/precision constants |Regenerate for new fixed N,B,q, routes and backend level|Constructive finite prescription required before varying e; old thresholds not imported| + +Here b0=.0034597,rho=.01. Root costs must remain +O(V[e^(1-rho)+e^((1-rho)(1-C1)+rho(1-b0))+e^rho log e]). +The existing positive adapter, stock and relaxation gaps absorb FIXED +constructively bounded constants. They do not absorb an unpriced new +asymptotic operation. All inherited analytic/native/tape/finite compiler +hypotheses remain individually stated. No physical full compiler invocation +or complete multiplier replay is part of this test. + +## Five-point expansion decision and stop + +1. Sources/status:4814/4760 merged archives with conditional author-side + certificates; explicit backend API coverage absent from independent.py. +2. Boundary:exact arbitrary owner inputs, source partial projector, paired + frames, two ROW levels, ancestors/spectators, padding and restoration above. +3. Obligation ledger:existing paid counts retained; new boundary lemmas under + test; final compiled route constants must be constructively bounded; + remaining primitive/outer hypotheses inherited. +4. Decision change:prove or refute the missing A0 API premise for the first + finite backend replacement, enabling or blocking its ordinary exponent + funding without changing any native paid profile. +5. Decision:NARROW to this one edge and one helper. Stop at a precise missing + source operation, domain/type mismatch, failed ownership/restoration or + unbounded route/padding charge. Do not launch a second helper, new prime, + all-size machine campaign, selected cold suite, root search or new compiler. + +Suggested budget60minutes after public GO, with the final quarter for source +pins, normal/optimized controls and handoff. A scoped missing-lemma report is +an acceptable stopping result. A positive result is an independent conditional +interface lemma, not human/kernel acceptance or a new overall kappa. Before +any further experimental expansion, return to the root and live ownership +check. Separate4940 complex work remains primary. + +Credit ai-nanachi4760/4814 and compact436/4326; rohanarun185 and the199/204 +bootstrap lineage; Cinna Davis/1337isnot1337, zxv and Jacob Alan Sussman for +native/compiler/whole-job/ROW interfaces; Mark/Matarener4697/4612; and the +retained E8/binary/scalar/tape/precision/outer contributors. Substantial +OpenAI Codex assistance. Apache-2.0. diff --git a/research/bit-completed-backend-api/proposal/SOURCES.json b/research/bit-completed-backend-api/proposal/SOURCES.json new file mode 100644 index 0000000000..35df9eae71 --- /dev/null +++ b/research/bit-completed-backend-api/proposal/SOURCES.json @@ -0,0 +1,103 @@ +{ + "confirmed_main": "cef4b52f2a59009865bf8eabde1be3f159063703", + "files": [ + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "AGENTS.md", + "sha256": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "CONTRIBUTING.md", + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "autoresearch.md", + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "docs/research/current-priorities.md", + "sha256": "db049fa3f75bd5345b23b736e51b7e912b39d372040b462c3e82610c482ff0c9" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "docs/research/agent-task-catalog.json", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "docs/research/research-family-status.md", + "sha256": "21ea61004c0270388258c4251b1c586b65f06bc807395b281deacfb886204934" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "docs/research/coordination.md", + "sha256": "61c78bc351a29e3346301da92b4da7ae096b73a977c550e281720f5375124804" + }, + { + "commit": "cef4b52f2a59009865bf8eabde1be3f159063703", + "path": "certificates/selected-result.json", + "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-finite-ordinary-bootstrap/PROOF.md", + "sha256": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-finite-ordinary-bootstrap/independent.py", + "sha256": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-finite-ordinary-bootstrap/RECORD.json", + "sha256": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-compact-productive-controller/PROOF.md", + "sha256": "f53d19d97d8f72a5c6408b392f80387d5fabfef16e37aee10f015e147f2698e4" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/bit-compact-productive-controller/independent_native.py", + "sha256": "2bd775c92ae5c79f82606909078c73ccf08eebc369faae2d111f74cb4e73ee87" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md", + "sha256": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json", + "sha256": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "notes/three-stage-cover-bit.tex", + "sha256": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "notes/three-stage-cover-rows.tex", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8" + }, + { + "commit": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "path": "notes/batched-bit-rows.tex", + "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c" + }, + { + "commit": "ecdfcabd56dfa663ae020733f9f1a88c6644743c", + "path": "research/bit-compact-productive-controller/local_word.py", + "sha256": "bfca7ff22066863086ebdb1cd67d26682fb167b8b11ff9be585f43ad36de06f3" + } + ], + "live_main_confirmed_by": "git ls-remote origin refs/heads/main", + "ownership_check": "Root monitor03:06UTC bounded4760/4814/4612comments,ai-nanachiDiscussions,1163/1166latest; no exactbridgeowner found; limited snapshot notnoveltyproof", + "status": "PROPOSAL_SOURCE_BINDING_ONLY" +} diff --git a/research/bit-completed-backend-api/proposal/TASK-PROPOSAL.json b/research/bit-completed-backend-api/proposal/TASK-PROPOSAL.json new file mode 100644 index 0000000000..33bb9d194e --- /dev/null +++ b/research/bit-completed-backend-api/proposal/TASK-PROPOSAL.json @@ -0,0 +1,89 @@ +{ + "canonical_main": "cef4b52f2a59009865bf8eabde1be3f159063703", + "canonical_question": "Does PR4760 completed ordinary A0 satisfy the arbitrary-width/spectator/ROW/radix and paid-routing hypotheses required at the first A1 call boundary of PR4814?", + "claim_live_required": true, + "experimental_execution_authorized": false, + "family": "ordinary-BIT/completed-finite-backend-composition", + "first_actual_fixture": { + "f": [ + 1, + 2 + ], + "frame": 506, + "helper": 462, + "rank": 4 + }, + "new_kappa_claim": false, + "original_card": { + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "existing_checks": [ + { + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "status": "author-checked" + }, + { + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "scope": "PR #3801: successor scatter-boundary decision package.", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "status": "author-checked" + } + ], + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "id": "supplier-boundary-audit", + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ] + }, + "outer_primitives_retained": true, + "priority_revision": 7, + "scope_change": "Refine historical4088four-provideradmissioncard to ONE current4814 first completed backend boundary A0(4760)->A1; no4088replay or selectedpromotion.", + "scope_status": "explicit_donor_refinement", + "status": "PROPOSAL_ONLY_NO_EXPERIMENT_EMITTED", + "track": "adversarial-audit" +} diff --git a/research/bit-completed-backend-api/science/PROOF.md b/research/bit-completed-backend-api/science/PROOF.md new file mode 100644 index 0000000000..a2db2c2bab --- /dev/null +++ b/research/bit-completed-backend-api/science/PROOF.md @@ -0,0 +1,311 @@ +# A conditional completed ordinary API implication for the first4814 backend edge + +This proves one source-bound implication, not the all-size native/compiler/tape +premises themselves. It audits A0(4760)->A1(4814), with actual helper462/frame506 +as its concrete whole-job witness. The original supplier-boundary-audit card, +its explicit donor refinement, main pin and public4945 scope are retained in +the immutable proposal above this implementation directory. + +## 1. Quantified premises and conclusion + +Freeze4760 ecdfcabd56dfa663ae020733f9f1a88c6644743c and4814 +f56ae4533a7d97d782a2c596a33fe844cd051747. Before varying the argument width, +fix the finite compiled word, its ambient N, all rational projector/matcher +matrices, distinct physical owners, finite route/precision/tape constants and +an odd prime avoiding their denominators and determinant witnesses. Retain: + +P1. The actual native finite word, chronological tensor/compiler and complete +whole-job implementation compute their stated projector endpoints on arbitrary +inputs, preserve complete spectator fields and restore their external ROW +coordinate. Product copies use distinct physical arrays; owned state remains +allocated until safe erasure. These are the source's explicit conditional +native/compiler hypotheses, not results of this experiment. + +P2. The inherited completed OLD ordinary atom supplier handles arbitrary widths, +two complete argument chunks, arbitrary preceding/intervening complete spectators, +and internally borrowed/restored ROW stock. The fixed-rational ordered-affine, +unit-scaling, controlled-shift and finite low-type routing lemmas have their +stated physical costs. No arbitrary address oracle or dense same-ARRAY map is +admitted. For4760 this older atom supplier has saving.0000384599. + +P3. The source stopped recurrence and reserve bound hold with the NEW fixed +program constants, not earlier numerical thresholds. The uniform4760/4814 +compiler and full delayed-cover fallback have the retained source hypotheses. +Ordinary data storage is initialized and padding/removal is charged. The +remaining analytic, prime, physical tape and outer premises are not discharged. + +Then the4760 construction of A0 has the completed ordinary type needed by the +FIRST4814 A1 backend edge: every A0 occurrence replaces an ordinary chunk +interchange with complete spectators and restored external ROW, using its own +argument chunks for internal stock. It needs no externally supplied new zero +ROW and no common inner/outer prime. The replacement preserves all fixed route, +weighted-leaf, high-part and padding costs. For the fixed three-level acyclic +chain, its type and positive exponent gaps propagate by finite induction. +This is a conditional composition proof with no new native invoice or kappa. + +The premises matter: accepting P1's ROW/physical ownership contract is not an +independent implementation proof of that full compiler. If a literal source +operation violates P1/P2, the conclusion cannot be used. We do not change the +original4814 record's actual_backend_API_independently_verified flag or call +an archive merge scientific acceptance. + +## 2. Actual partial helper and all positive column widths + +Helper462 is an arbitrary original input starting at frame0 and ending at +frame506, with rank4. Read its rational B (image rows) and A (kernel rows) +from the exact source frame bank. Set + + P = B^T (B B^T)^-1 B, + S = [B^T | A^T], Q=diag(I4,0). + +The rowspaces are complementary and orthogonal in this actual frame, so S is +invertible, P^2=P, and S Q S^-1=P. Our code reconstructs these matrices from +source bytes without importing the predecessor helper_matchers function. +For positive f, let Pf=P tensor I_f, Sf=S tensor I_f. With actual reversal +C_(8f)=C8 tensor C_f, define + + D_P = [ I-P P C ], Q_S=diag(S,C S C). + [ C P I-C P C ] + +Block multiplication gives Q_S D_Q Q_S^-1=D_P. Kronecker multiplication and +C_f^2=I give the same identity for every f. The source's rank4 job becomes +rank4f with identity spectators; it is not a rank8f job. These equalities are +linear coordinate permutations after valid reduction to the source local +ring; equality of the coordinate maps implies equality on arbitrary input +functions. No inference from a few special Boolean data inputs is needed. + +Let a parent request be D_(gPg^-1) on the complete cover row g, and the child +canonical target be D_(hQh^-1). Push the parent's whole role fiber to h=gS, +execute the complete child and return by S^-1. Then + + (gS) Q (gS)^-1 = g P g^-1. + +Right multiplication by the invertible fixed S is a bijection of the entire +GL cover, so no arbitrary input is discarded/copied or assumed zero. Source +'gather' notation can list S^-1 for the input address lookup; our statement +uses the explicit push convention above. Both routes remain paid. + +At f1/f2, small witnesses modulo25 and49 compare the canonical routed physical +operator, applied to every linear coordinate basis vector, with a separately +implemented direct projector action. There are384 such basis-column checks. +These small rings do not replace the actual q>2^45 N^5 rule. The proof is over +the rational identities and valid local-ring reductions at every width. + +## 3. Weights, complete cover rows and real carries + +The parent's external unit weight may depend on exposed ancestor coordinates +and column index but is independent of the current fresh cover row/roles. +Its address map Lambda=diag(A,I) therefore commutes with the fiber route: +the route changes g only and Lambda has the same value before/after it. This +is an equality of two maps on the product domain, not a claim that arbitrary +matrix S commutes with a diagonal matrix A on one ARRAY. Conjugating the +whole routed word gives the requested weighted projector endpoint. + +A leaf weight can depend on the current OUTER g because that g is a spectator +ancestor of the INNER call. It must remain independent of the inner fresh row. +An inner ordinary call receives all outer row/head/type fields as complete +spectators; its own stock is disjoint. This is exactly the completed type in +P1/P2, not a heterogeneous-weight supplier assumption. The finite control uses +a nonzero address and two actual row representatives to show that a weight +illegally reading the fresh row produces unequal route/weight composites. + +Write g=g0+qG1. For a fixed rational matcher reduced modulo q^w, let +h0=(g0 S) mod q. The high-coordinate map is + + G1 -> G1 S + (g0 S-h0)/q (mod q^(w-1)). + +For each finite low type g0, every entry of G1 ranges independently over the +complete local ring; invertibility depends only on g0. Thus ordinary chunk +operations see complete ranges and all other high entries as spectators. +The carry is determined by the fixed low type and source matcher and is +charged. The code separately reconstructs this formula at w2 with nonzero +high matrix and rejects dropping its actual carry. A finite low-type +permutation is also paid; it is not an unpriced gather. + +For this S, deterministic rational elimination yields5 swaps,5 unit scalings +and14 shears, and reconstructs S in the exact chronological right-product +order. On the8-row high matrix, ONE route consequently uses40 ordinary chunk +interchanges,40 fixed unit scalings,112 linear ordered shifts and at most64 +carry shifts, plus one finite low-type permutation. Its inverse has the same +conservative counts. The PAIR ledger is80 ordinary interchanges,80 scalings, +224 linear shifts, at most128 carry shifts and2 low-type permutations. +The tensor multiplicity f does not enlarge the8-dimensional cover row. +An embedding into a fixed larger compiler N gives a finite constructive count +by the same elimination and high-row algorithm. The count depends on that +fixed program; it is not assumed uniformly constant as N changes. + +Each ordinary interchange uses the completed backend with the other high +coordinates/low type as spectators. The ordered-affine/unit-scaling primitive +cost remains inherited P2, explicitly charged. The finite low-type permutation +can be generated by a finite table/cycle decomposition, whose size is bounded +by |GL_N(F_q)|; its source physical routing implementation is retained. We +have not executed the astronomical compiled routing list or independently +proved P2's tape realization. Their charges remain finite algorithm-derived +constants, never zero. + +## 4. Weighted atoms consume exactly the available completed API + +For every unit a in a commutative source local ring, let + + J1=[0 1;1 0], L(b)=[1 0;b 1], U(a)=[1 a;0 1]. + +The exact identities are U(a)=J1 L(a) J1 and + + Ja=diag(1,-1) U(a) L(-a^-1) U(a)=[0 a;a^-1 0]. + +Consequently the chronological literal word uses4 OLD ordinary J1 calls, +3 prefix-controlled shifts and1 fixed sign. It requires no weighted backend +primitive. Every J1 exchanges two complete atom chunks with all descriptor/ +ancestor/ROW fields as spectators. Unequal inner prime is handled at the +completed ordinary endpoint, as below. The code checks this exact word over +rational units2 and3 and rejects deleting an actual J1. It does not replace +Ja by an oracle or assume differently weighted internal jobs can mix. + +## 5. Completed ordinary body and two ROW levels + +For any module of chunk coordinates and any reversal involution C, assume a +completed raw body F_n(H,D)=(C D,C H) preserves its external ROW/spectators. +Trace the actual chronological source wrapper: + + D-=H; F_n; D+=H; F_n; D=H-D. + +Starting at arbitrary H,D its states are +(H,D-H), (C(D-H),C H), (C(D-H),C D), (D,D-H), (D,H). +External fields are unchanged at every raw-call return. Three additive maps +are charged and the two completed F_n calls reuse the same restored reserve. +Their fixed multiplicity is outside the stopped recurrence, not a factor +inserted into every characteristic-moment branch. + +Borrowing is also explicit. Split the original complete argument chunks as +H=(H_hi,H_body), D=(D_hi,D_body). Reinterpret H_hi as the preceding ROW for +the ordinary body call; D_hi and original intervening Z remain spectators. +After the completed body the state is + + H_hi, D_body, Z, D_hi, H_body. + +Restore/unpad the ROW before the completed high-part interchange, then swap +H_hi,D_hi with the bodies/Z as spectators. The exact result is D,Z,H. The +borrowed high data was arbitrary original data; it was neither initialized +nor discarded. With k=ceil(log_q S(e,w))=O(w log e), k=S. Those constants +multiply only finitely in three named levels, not once per coarse recursion +node. The completed genuine-rectangle invariant permits unpadding at each +return boundary. Every initialization, retention and removal remains paid. + +The small witnesses use q5/q7,w2, padding25 to32 and49 to64, giving paired +volume ratios1024/625 and4096/2401, each<4. A row divisor3 pads the row ranges +to27 and51, charging2 owned added rows in each case. These are type fixtures, +not actual large-q compiler executions or practical stock thresholds. Replacing +the completed endpoint by the source odd-radix atom-reversed body maps the +genuine rectangle out of itself. For caller range25, use inner radix7 with +2 atoms (range49); for caller range49, use inner radix5 with3 atoms (range125). +These full cross-radix factors are2401/625 and15625/2401, respectively. They +include the separately charged inner fixed-radix conversion and are not +claimed below4: that bound applies only to the two binary padding ranges. +The returned counterexample addresses are retained in RESULT.json; this +rejection is not a synthetic malformed padding label. This provides a discriminating reason the source's completed boundary +is necessary. + +## 7. Complete first-edge price type and finite chain + +No raw rank/profile changes occur. The inherited4760 caller retains11400 +original owners,57339 paid queries and7848 global helper originals; +its local supplier has436 independent helpers. +All nine paid rank7 COPY episodes per local FULL remain charged. There are +72 partial rank4 output jobs,144 added matcher routes and7548 other raw +nonidentity port routes. Their sum7692 is a RAW route census, not the count +after uniform compilation. + +Every fixed compiled matcher pair consumes its paid completed ordinary route, +fixed shifts/scalings/carries and owned movement. Every weighted leaf consumes +4 ordinary atom interchanges. Cover fallback remains paid with the source +2N^3/q fraction and up to32N^2 bad children, under the new fixed large-prime +budget. Target completion and splitting are unchanged. No new productive +credit is introduced by padding, ROW or copies. + +Set b0=.0034597,rho=.01,C1=.00347545805-(2^-36+10^-20). By P1-P3, after fixing +all new finite constants, the three root costs have the source form + + O(V[e^(1-rho) + +e^((1-rho)(1-C1)+rho(1-b0)) + +e^rho log e]). + +The middle exponent is1-a1 for a1=(1-rho)C1+rho b0. Actual computed rational +gaps establish b02^45 N^5, a compiler-size test or a stock threshold. +- Seven independent boundary controls reject an omitted matcher, omitted column + tail reversal, fresh-ROW-dependent weight, inner ROW alias, missing weighted + leaf swap, premature unpadding after the source odd-radix raw reversed body and dropped + high-matrix carry. Comparisons use coordinate actions or returned states; + they do not merely compare two copies of the asserted equality. + +The finite code corroborates the generic proof. It does not infer universal +arbitrary-input correctness solely from those22 cases. No full658/11400 RAW +native replay or astronomical compiled program was executed. + +## Complete cost boundary + +All4760 ranks remain unchanged:11400 original owners,57339 paid queries, +7848 helper originals, all nine rank7 COPY charges per local FULL retained. +The144 added partial-helper matching routes and7548 inherited port routes +remain paid; their raw total7692 is not a final compiled count. + +For the selected coarse8-dimensional matcher pair, explicit high-matrix +routing uses80 completed ordinary chunk interchanges,80 fixed unit scalings, +224 linear ordered shifts, at most128 carry shifts and2 finite low-type +permutations. Each is charged by the source fixed-rational routing primitive; +the two low-type permutations and their finite table/cycle costs remain +separate. This is a conservative constructive bound, not a practical tape +constant or a reduction of the inherited route count. For a fixed larger +compiled N, the same finite elimination/high-row algorithm gives its new +N-dependent constant before argument width varies. + +Every weighted atom uses4 completed ordinary swaps,3 controlled shifts and +1 fixed sign. Every completed ordinary body uses2 completed raw bodies and +3 additions; high-part exchange, row/radix padding, stock initialization and +removal, owned erasure, completion/splitting and full bad-class fallback remain +charged. Positive existing adapter/stock/relaxation gaps absorb fixed +constructively bounded constants, not an unknown asymptotic operation. + +Given the retained primitive bounds, the first-edge root costs remain + + O(V[e^.99 + e^(.99(1-C1)+.01(1-.0034597)) + e^.01 log e]), + +where C1=.00347545805-(2^-36+10^-20). The written proof then freezes each +backend before the next and obtains the existing finite3-level induction. +Exact Fraction checks reproduce the already declared stage gaps; no new +exponent is extracted. This validates the composition's type/cost implication +inside its conditional model, not a complete ordinary supplier implementation. + +## What still blocks full independent admission + +The actual finite native/compiler program's ROW restoration and distinct +physical allocation at all widths, the source ordered-affine/scaling/tape +implementation, generated precision/machine constants and analytic/outer +recovery remain inherited. They are explicitly P1-P3 in PROOF.md. The code +sets full4814_primitive_API_independently_proved=False. If an unconditional or +complete physical API audit is desired, it needs a literal source-bound +N-dimensional physical stock/role/route generator satisfying those premises. +Another root evaluation or this local fixture cannot supply it. + +The current positive result can strengthen the justification that4814's +conditional ordinary.003475458 uses no stronger completed interface than its +retained source allows. It cannot independently promote that record from an +archival/partially-reviewed status, prove the underlying BIT machine or raise +the global bound while the complex supplier binds. Separate4940 work remains +primary. Independent review is required before the root treats this finding +as accepted; this packet contains author checks only until that review lands. + +## Reproduction and source/credit + +Read-only from the worktree root: + + python3 -I -B outputs/bit-completed-backend-api-gate/implementation/check.py + python3 -I -O -B outputs/bit-completed-backend-api-gate/implementation/check.py + +Explicit --write writes only RESULT.json and implementation/SOURCES.json. +The script fetches immutable source Git objects; no network, primary checker +import or shared source write is performed. Normal/O stdout must match. +The formal typed inner raw contract in the fixtures is clearly labelled; +it is not a disguised claim to execute the actual full compiler. + +Credit ai-nanachi4760/4814/4326; rohanarun185/199 and Maxime Fleury204; +Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612, +and the retained whole-job/ROW/native/precision/tape/outer lineage. New4944 +(physically typed CRT placement) and4942 (that callee's branch threshold) +are neighboring source-bound uses, not this completed-backend proof; their +CRT layouts and threshold calculations are not repeated. Substantial OpenAI +Codex assistance, Apache-2.0. No human or proof-kernel review is claimed. + +## Preserved first freeze and corrected negative controls + +The initial local seven-file freeze remains unchanged under +history/prior-controls/. Independent reviewer B found that the wrong-tail +control checked only unequal reversal matrices, and the padding control used +binary reversal instead of the source odd-radix raw F_n. The current controls +compare a mutated physical endpoint after the correct source routes, and +source-typed C2/C3 cross-radix returns25→49 (base7) and49→125 (base5). +Actual failing coordinates/addresses are recorded. Their full padding factors +include the separately charged inner-radix conversion; they are not called +less than4. The positive22 fixtures,384 columns, written generic proof and +price/type conclusions are unchanged. The correction does not claim the +old two weaker controls established the same coverage. diff --git a/research/bit-completed-backend-api/science/RESULT.json b/research/bit-completed-backend-api/science/RESULT.json new file mode 100644 index 0000000000..55dca30281 --- /dev/null +++ b/research/bit-completed-backend-api/science/RESULT.json @@ -0,0 +1,2542 @@ +{ + "all_width_proof": "See PROOF.md; finite fixtures are corroboration only", + "arbitrary_data_scope": "Exact coordinate operator identities + written universal permutation/interface proof; no full arrays or astronomical template executed", + "column_multiplicities": [ + 1, + 2 + ], + "controls": { + "fresh_ROW_weight": true, + "inner_ROW_alias": true, + "omit_column_tail_reversal": { + "actual": "0", + "basis_column": 26, + "output_coordinate": 2, + "wrong": "1/2" + }, + "omit_high_matrix_carry": true, + "omit_matcher": true, + "omit_weighted_leaf_swap": true, + "premature_padding_cleanup": [ + { + "caller_radix": 5, + "genuine_range": 25, + "inner_radix": 7, + "inner_width": 2, + "input": [ + 0, + 4 + ], + "padded_inner_range": 49, + "raw_output": [ + 28, + 0 + ] + }, + { + "caller_radix": 7, + "genuine_range": 49, + "inner_radix": 5, + "inner_width": 3, + "input": [ + 0, + 2 + ], + "padded_inner_range": 125, + "raw_output": [ + 50, + 0 + ] + } + ] + }, + "finite_levels": [ + { + "adapter_gap": "4276027093749855738909939/655360000000000000000000000", + "admitted": "8688251/2500000000", + "backend": "34597/10000000", + "exact": "2277572906250144261090061/655360000000000000000000000", + "relaxation_gap": "36106144261090061/655360000000000000000000000", + "stock_gap": "646528827093749855738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275924854968415738909939/655360000000000000000000000", + "admitted": "8688641/2500000000", + "backend": "8688251/2500000000", + "exact": "2277675145031584261090061/655360000000000000000000000", + "relaxation_gap": "38727584261090061/655360000000000000000000000", + "stock_gap": "646528724854968415738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275923832606815738909939/655360000000000000000000000", + "admitted": "1737729/500000000", + "backend": "8688641/2500000000", + "exact": "2277676167393184261090061/655360000000000000000000000", + "relaxation_gap": "12513184261090061/655360000000000000000000000", + "stock_gap": "646528723832606815738909939/655360000000000000000000000" + } + ], + "fixture_cap": 64, + "fixtures": [ + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + } + ], + "full4814_primitive_API_independently_proved": false, + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "native_rawbody_ROW_semantics": "Inherited premise; wrapper proof checks its exact use, not actual full compiler implementation", + "new_kappa": false, + "original_helper": 462, + "padding_fixtures": [ + { + "binary_range": 32, + "digit_width": 2, + "full_cross_radix_volume_factor": "2401/625", + "inner_padded_range": 49, + "inner_radix": 7, + "inner_width": 2, + "owned_padded_rows": 2, + "padded_row_range": 27, + "radix": 5, + "range": 25, + "row_divisor": 3, + "two_range_volume_factor": "1024/625" + }, + { + "binary_range": 64, + "digit_width": 2, + "full_cross_radix_volume_factor": "15625/2401", + "inner_padded_range": 125, + "inner_radix": 5, + "inner_width": 3, + "owned_padded_rows": 2, + "padded_row_range": 51, + "radix": 7, + "range": 49, + "row_divisor": 3, + "two_range_volume_factor": "4096/2401" + } + ], + "physical_basis_columns_checked": 384, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "right_route_elimination_counts": { + "add": 14, + "scale": 5, + "swap": 5 + }, + "right_route_factors": [ + [ + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "2", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + ], + "routing_cost_primitive": "Inherited fixed-rational ordered-affine/scaling/shift lemma; every elementary factor is charged", + "selected_record_changed": false, + "selected_route_pair_high_matrix_ledger": { + "carry_ordered_shifts_upper": 128, + "fixed_unit_scalings": 80, + "linear_ordered_shifts": 224, + "low_type_permutations": 2, + "ordinary_chunk_interchanges": 80, + "scope": "N=8 coarse head; all charged; low-type finite-permutation costs separate; tensor f does not enlarge cover row dimension" + }, + "small_fixtures": 22, + "source_frame": 506, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "status": "PASS_ONE_CONDITIONAL_A0_TO_A1_API_IMPLICATION_NOT_PRIMITIVE_ADMISSION", + "weighted_leaf_fixtures": [ + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 3 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 3 + } + ] +} diff --git a/research/bit-completed-backend-api/science/SOURCES.json b/research/bit-completed-backend-api/science/SOURCES.json new file mode 100644 index 0000000000..27666c7299 --- /dev/null +++ b/research/bit-completed-backend-api/science/SOURCES.json @@ -0,0 +1,15 @@ +{ + "checker_sha256": "0a3a90c4d74174f90047cdae1efcc71e30cef7dba48bb55536c43fc75394747e", + "files": { + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "research/bit-finite-ordinary-bootstrap/PROOF.md": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "research/bit-finite-ordinary-bootstrap/RECORD.json": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "research/bit-finite-ordinary-bootstrap/independent.py": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "schema_version": 1, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747" +} diff --git a/research/bit-completed-backend-api/science/check.py b/research/bit-completed-backend-api/science/check.py new file mode 100644 index 0000000000..74ee4911f1 --- /dev/null +++ b/research/bit-completed-backend-api/science/check.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python3 +"""One source-bound conditional completed ordinary backend API gate. +No predecessor executable/price engine imported. Apache-2.0; Codex assistance. +""" +from pathlib import Path +from fractions import Fraction as F +from hashlib import sha256 +from collections import Counter +import json,subprocess,sys +HERE=Path(__file__).resolve().parent +PIN='f56ae4533a7d97d782a2c596a33fe844cd051747' +PATHS={'frames':'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json','word':'research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz','proof':'research/bit-finite-ordinary-bootstrap/PROOF.md','independent':'research/bit-finite-ordinary-bootstrap/independent.py','bridge':'research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md','bit':'notes/three-stage-cover-bit.tex','rows':'notes/three-stage-cover-rows.tex','record':'research/bit-finite-ordinary-bootstrap/RECORD.json'} +def need(x,m): + if not x:raise ValueError(m) +def eye(n):return [[F(i==j)for j in range(n)]for i in range(n)] +def tr(a):return list(map(list,zip(*a))) +def mm(a,b):return [[sum((x*y for x,y in zip(r,c)),F(0))for c in zip(*b)]for r in a] +def add(a,b,k=1):return [[x+k*y for x,y in zip(r,s)]for r,s in zip(a,b)] +def inverse(a): + n=len(a);w=[list(r)+e for r,e in zip(a,eye(n))] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]);w[j],w[k]=w[k],w[j];v=w[j][j];w[j]=[x/v for x in w[j]] + for i in range(n): + if i!=j: + z=w[i][j];w[i]=[x-z*y for x,y in zip(w[i],w[j])] + return [r[n:]for r in w] +def kron(a,f):return [[a[i//f][j//f]*F(i%f==j%f)for j in range(len(a[0])*f)]for i in range(len(a)*f)] +def paired(p): + n=len(p);c=[[F(i+j==n-1)for j in range(n)]for i in range(n)];u=add(eye(n),p,-1) + return [x+y for x,y in zip(u,mm(p,c))]+[x+y for x,y in zip(mm(c,p),mm(mm(c,u),c))] +def paired_map(s): + n=len(s);z=[[F(0)]*n for _ in range(n)];c=[[F(i+j==n-1)for j in range(n)]for i in range(n)] + return [x+y for x,y in zip(s,z)]+[x+y for x,y in zip(z,mm(mm(c,s),c))] +def mod(a,m):return [[(x.numerator*pow(x.denominator,-1,m))%m for x in r]for r in a] +def mv(a,v,m):return [sum(x*y for x,y in zip(r,v))%m for r in a] +def direct_action(p,v,m): + # Independently apply the actual projector law coordinate-by-coordinate. + n=len(p);h,t=v[:n],v[n:];ph=mv(p,h,m);pct=mv(p,list(reversed(t)),m) + return [(h[i]-ph[i]+pct[i])%m for i in range(n)]+[(t[i]+ph[n-1-i]-pct[n-1-i])%m for i in range(n)] +def decompose(s): + w=[r[:]for r in s];n=len(s);ops=[] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]) + if k!=j:w[j],w[k]=w[k],w[j];ops.append(('swap',j,k,F(1))) + v=w[j][j] + if v!=1:w[j]=[x/v for x in w[j]];ops.append(('scale',j,j,1/v)) + for i in range(n): + if i!=j and w[i][j]: + z=-w[i][j];w[i]=[x+z*y for x,y in zip(w[i],w[j])];ops.append(('add',i,j,z)) + need(w==eye(n),'deterministic rational elimination') + factors=[] + for typ,i,j,z in ops: + e=eye(n) + if typ=='swap':e[i],e[j]=e[j],e[i] + elif typ=='scale':e[i][i]=1/z + else:e[i][j]=-z + factors.append(e) + out=eye(n) + for e in factors:out=mm(out,e) + need(out==s,'literal right multiplier factor order') + return ops,factors + +def wrapper(h,d,rows,raw): + # Source exact completed ordinary body; rows are read-only spectators of raw. + h=list(h);d=[y-x for x,y in zip(h,d)];h,d,r=raw(h,d,rows) + d=[x+y for x,y in zip(d,h)];h,d,r=raw(h,d,r) + d=[x-y for x,y in zip(h,d)] + return h,d,r + +def main(): + raw={k:subprocess.check_output(['git','--no-replace-objects','show',PIN+':'+p])for k,p in PATHS.items()} + need(sha256(raw['frames']).hexdigest()=='d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010','actual source frame bank') + import gzip + word=json.loads(gzip.decompress(raw['word']));frame=json.loads(raw['frames'])['frames']['506'] + need(word['start'][462]==0 and word['final'][462]==506 and frame['dim']==4,'actual arbitrary helper462 rank4') + B=[[F(x)for x in r]for r in frame['B']];A=[[F(x)for x in r]for r in frame['A']] + P=mm(mm(tr(B),inverse(mm(B,tr(B)))),B);S=tr(B+A);Si=inverse(S);Q=[[F(i==j and i<4)for j in range(8)]for i in range(8)] + need(mm(P,P)==P and mm(mm(S,Q),Si)==P,'source rational idempotent and matcher') + ops,factors=decompose(S);need(all(x.denominator%5 and x.denominator%7 for r in S+Si+P for x in r),'declared fixture primes valid') + controls={};fixtures=[];basis_columns=0 + for f in (1,2): + Pf,Sf,Qf=kron(P,f),kron(S,f),kron(Q,f);n=8*f;Sfi=inverse(Sf) + need(mm(mm(paired_map(Sf),paired(Qf)),paired_map(Sfi))==paired(Pf),'actual reversed-tail all-f tensor form in fixture') + # This wrong C8 tensor I_f must fail at f2, unless accidentally symmetric. + if f==2: + wrong=[[F(i//f+j//f==7 and i%f==j%f)for j in range(n)]for i in range(n)] + # Mutate the actual canonical child's tail pairing, then use the + # correct source routes; compare the returned physical endpoint. + u=add(eye(n),Qf,-1) + wrong_child=[x+y for x,y in zip(u,mm(Qf,wrong))]+[x+y for x,y in zip(mm(wrong,Qf),add(eye(n),mm(mm(wrong,Qf),wrong),-1))] + wrong_endpoint=mm(mm(paired_map(Sf),wrong_child),paired_map(Sfi)) + actual_endpoint=paired(Pf) + mismatch=next((i,j)for i in range(2*n)for j in range(2*n)if wrong_endpoint[i][j]!=actual_endpoint[i][j]) + need(wrong_endpoint!=actual_endpoint,'wrong tail actual returned physical operator fails') + controls['omit_column_tail_reversal']={'basis_column':mismatch[1],'output_coordinate':mismatch[0],'wrong':str(wrong_endpoint[mismatch[0]][mismatch[1]]),'actual':str(actual_endpoint[mismatch[0]][mismatch[1]])} + for prime in (5,7): + m=prime**2 + for variant in (0,1): + g=eye(8);g[0][1]=F(variant);gi=inverse(g);h=mm(g,S) + gp=mm(mm(g,P),gi);hq=mm(mm(h,Q),inverse(h));need(gp==hq,'whole cover route g to gS correct') + need(mm(h,Si)==g,'exact row inverse return') + # A genuinely independent coordinate path: route via gS,Q then undo vs + # direct requested projector gPg^-1 on every linear coordinate basis. + routed=paired_map(kron(h,f));unroute=paired_map(kron(inverse(h),f));canonical=paired(Qf) + dp=mod(kron(gp,f),m);ri=mod(unroute,m);rc=mod(canonical,m);ro=mod(routed,m) + # Independent q-adic high-matrix route/carry, with fixed nonzero high part. + g0=mod(g,prime);G1=[[0]*8 for _ in range(8)];G1[1][0]=1 + sm=mod(S,m);slow=mod(S,prime) + gw=[[g0[i][j]+prime*G1[i][j]for j in range(8)]for i in range(8)] + direct=mod(mm(gw,sm),m);z=mm(g0,sm) + low=[[int(x)%prime for x in row]for row in z] + carry=[[(int(z[i][j])-low[i][j])//prime%prime for j in range(8)]for i in range(8)] + linear=mod(mm(G1,slow),prime) + high=[[(linear[i][j]+carry[i][j])%prime for j in range(8)]for i in range(8)] + rebuilt=[[low[i][j]+prime*high[i][j]for j in range(8)]for i in range(8)] + need(direct==rebuilt,'actual whole-cover high affine route including carry') + without=[[low[i][j]+prime*linear[i][j]for j in range(8)]for i in range(8)] + need(without!=direct,'omitting real route carry fails') + controls['omit_high_matrix_carry']=True + for ancestor in (0,1): + weights=[1+(i+ancestor)%2 for i in range(n)] + lam=eye(2*n);lami=eye(2*n) + for i,a in enumerate(weights):lam[i][i]=a;lami[i][i]=F(1,a) + lm,li=mod(lam,m),mod(lami,m) + for j in range(2*n): + v=[int(i==j)for i in range(2*n)] + lhs=mv(lm,mv(ro,mv(rc,mv(ri,mv(li,v,m),m),m),m),m) + rhs=mv(lm,direct_action(dp,mv(li,v,m),m),m) + need(lhs==rhs,'independent all-basis weighted physical helper route') + basis_columns+=1 + # Two visible ROW levels + a complete spectator, held by the raw contract. + r={'outer':(prime,variant),'inner':(ancestor,prime+1),'spectator':(3,7,11)} + x=[F(i+1)for i in range(n)];y=[F(2*i-3)for i in range(n)] + rawbody=lambda a,b,row:(list(reversed(b)),list(reversed(a)),dict(row)) + def inner_completed(a,b,row): + # Inner ROW is borrowed from the CURRENT argument's own high part, + # not a new arbitrary owner or externally supplied empty stock. + ah,bh=list(a[:1]),list(b[:1]);ar,br=list(a[1:]),list(b[1:]) + borrowed=dict(row);borrowed['borrowed_inner_ROW']=tuple(ah) + ao,bo,ret=wrapper(ar,br,borrowed,rawbody) + need(ret==borrowed,'inner completed body restores borrowed/current high ROW') + del ret['borrowed_inner_ROW'] + # One completed high-part interchange, after ROW restoration. + return bh+ao,ah+bo,ret + def nested_raw(a,b,row): + aa,bb,ret=inner_completed(a,b,row) + return list(reversed(aa)),list(reversed(bb)),ret + xo,yo,rr=wrapper(x,y,r,nested_raw) + need(xo==y and yo==x and rr==r,'completed wrapper arbitrary typed ROWs') + # The second nesting order is a control: overwrite outer row by inner. + def badbody(a,b,row): + row=dict(row);row['outer']=row['inner'];return list(reversed(b)),list(reversed(a)),row + _,_,bad=wrapper(x,y,r,badbody);need(bad!=r,'unrestored/aliased ROW control') + controls['inner_ROW_alias']=True + fixtures.append({'f':f,'prime':prime,'modulus':m,'g_variant':variant,'ancestor':ancestor,'basis_columns':2*n,'two_ROW_levels_preserved':True,'inner_stock_borrowed_from_argument':True}) + # Non-tautological fresh weight failure: the route changes the row queried + # by the illegal weight. Choose the already declared variant1, no search. + g=eye(8);g[0][1]=1;h=mm(g,S) + fresh=lambda z:1+int(z[0][1]==0) + need(fresh(g)!=fresh(h),'fresh-row weight descriptor changes on actual route') + address=[1]+[0]*15 + left=(tuple(map(tuple,h)),fresh(g)*address[0]) + right=(tuple(map(tuple,h)),fresh(h)*address[0]) + need(left!=right,'actual fresh-row scaling and route commutator on nonzero address') + controls['fresh_ROW_weight']=True + # Four OLD ordinary swaps, three shifts, one fixed sign; exact modular word. + I=eye(2);J=[[F(0),F(1)],[F(1),F(0)]] + def L(a):return [[F(1),F(0)],[F(a),F(1)]] + sig=[[F(1),F(0)],[F(0),F(-1)]];weighted=[] + for prime in (5,7): + m=prime**2 + for a in (2,3): + aa=F(a);word=[J,L(aa),J,L(-1/aa),J,L(aa),J,sig] + op=I + for e in word:op=mm(e,op) + expected=[[F(0),aa],[1/aa,F(0)]] + need(op==expected,'literal4 ordinary weighted leaf swaps') + bad=I + for k,e in enumerate(word): + if k!=0:bad=mm(e,bad) + need(bad!=expected,'omitted ordinary atom interchange') + controls['omit_weighted_leaf_swap']=True;weighted.append({'prime':prime,'unit':a,'ordinary_swaps':4,'shifts':3,'signs':1}) + # Padding uses the invariant genuine rectangle, not an assumed inverse of + # an internally uncompleted body. These address permutations are independent + # of the rational matrix helper checks above. + padding=[] + for radix in (5,7): + original=radix**2;padded=1<<(original-1).bit_length();need(padded<2*original,'two chunk binary pad bound') + genuinely=set((i,j)for i in range(original)for j in range(original));returned={(j,i)for i,j in genuinely} + need(returned==genuinely,'completed ordinary swap preserves genuine rectangle') + need(all((i=row_stock and row_padded<2*source,'owned ROW pad bound') + # Source F_n reverses ODD-RADIX atom positions, not binary bits. + # Keep caller radix5/7 and use the other declared prime internally. + inner=7 if radix==5 else 5;inner_width=2 if radix==5 else 3;inner_range=inner**inner_width + def rev(n): + out=0 + for _ in range(inner_width):out=out*inner+n%inner;n//=inner + return out + bad={(rev(j),rev(i))for i,j in genuinely} + need(bad!=genuinely,'source odd-radix raw reversed body violates genuine rectangle') + witness=next((i,j)for i in range(original)for j in range(original)if rev(j)>=original or rev(i)>=original) + controls.setdefault('premature_padding_cleanup',[]).append({'caller_radix':radix,'genuine_range':original,'inner_radix':inner,'inner_width':inner_width,'padded_inner_range':inner_range,'input':list(witness),'raw_output':[rev(witness[1]),rev(witness[0])]}) + padding.append({'radix':radix,'digit_width':2,'range':original,'binary_range':padded,'two_range_volume_factor':str(F(padded**2,original**2)),'inner_radix':inner,'inner_width':inner_width,'inner_padded_range':inner_range,'full_cross_radix_volume_factor':str(F(inner_range**2,original**2)),'row_divisor':row_stock,'padded_row_range':row_padded,'owned_padded_rows':row_padded-source}) + # Reject omitted physical whole-job matcher with actual matrices. + controls['omit_matcher']=paired(Q)!=paired(P) + need(all(controls.values()),'every semantic control distinguishes') + C1=F('.00347545805')-F(1,2**36)-F(1,10**20);rho=F(1,100);b=F('.0034597');levels=[] + for value in (F('.0034753004'),F('.0034754564'),F('.0034754580')): + a=(1-rho)*C1+rho*b;need(bA1(4814), with actual helper462/frame506 +as its concrete whole-job witness. The original supplier-boundary-audit card, +its explicit donor refinement, main pin and public4945 scope are retained in +the immutable proposal above this implementation directory. + +## 1. Quantified premises and conclusion + +Freeze4760 ecdfcabd56dfa663ae020733f9f1a88c6644743c and4814 +f56ae4533a7d97d782a2c596a33fe844cd051747. Before varying the argument width, +fix the finite compiled word, its ambient N, all rational projector/matcher +matrices, distinct physical owners, finite route/precision/tape constants and +an odd prime avoiding their denominators and determinant witnesses. Retain: + +P1. The actual native finite word, chronological tensor/compiler and complete +whole-job implementation compute their stated projector endpoints on arbitrary +inputs, preserve complete spectator fields and restore their external ROW +coordinate. Product copies use distinct physical arrays; owned state remains +allocated until safe erasure. These are the source's explicit conditional +native/compiler hypotheses, not results of this experiment. + +P2. The inherited completed OLD ordinary atom supplier handles arbitrary widths, +two complete argument chunks, arbitrary preceding/intervening complete spectators, +and internally borrowed/restored ROW stock. The fixed-rational ordered-affine, +unit-scaling, controlled-shift and finite low-type routing lemmas have their +stated physical costs. No arbitrary address oracle or dense same-ARRAY map is +admitted. For4760 this older atom supplier has saving.0000384599. + +P3. The source stopped recurrence and reserve bound hold with the NEW fixed +program constants, not earlier numerical thresholds. The uniform4760/4814 +compiler and full delayed-cover fallback have the retained source hypotheses. +Ordinary data storage is initialized and padding/removal is charged. The +remaining analytic, prime, physical tape and outer premises are not discharged. + +Then the4760 construction of A0 has the completed ordinary type needed by the +FIRST4814 A1 backend edge: every A0 occurrence replaces an ordinary chunk +interchange with complete spectators and restored external ROW, using its own +argument chunks for internal stock. It needs no externally supplied new zero +ROW and no common inner/outer prime. The replacement preserves all fixed route, +weighted-leaf, high-part and padding costs. For the fixed three-level acyclic +chain, its type and positive exponent gaps propagate by finite induction. +This is a conditional composition proof with no new native invoice or kappa. + +The premises matter: accepting P1's ROW/physical ownership contract is not an +independent implementation proof of that full compiler. If a literal source +operation violates P1/P2, the conclusion cannot be used. We do not change the +original4814 record's actual_backend_API_independently_verified flag or call +an archive merge scientific acceptance. + +## 2. Actual partial helper and all positive column widths + +Helper462 is an arbitrary original input starting at frame0 and ending at +frame506, with rank4. Read its rational B (image rows) and A (kernel rows) +from the exact source frame bank. Set + + P = B^T (B B^T)^-1 B, + S = [B^T | A^T], Q=diag(I4,0). + +The rowspaces are complementary and orthogonal in this actual frame, so S is +invertible, P^2=P, and S Q S^-1=P. Our code reconstructs these matrices from +source bytes without importing the predecessor helper_matchers function. +For positive f, let Pf=P tensor I_f, Sf=S tensor I_f. With actual reversal +C_(8f)=C8 tensor C_f, define + + D_P = [ I-P P C ], Q_S=diag(S,C S C). + [ C P I-C P C ] + +Block multiplication gives Q_S D_Q Q_S^-1=D_P. Kronecker multiplication and +C_f^2=I give the same identity for every f. The source's rank4 job becomes +rank4f with identity spectators; it is not a rank8f job. These equalities are +linear coordinate permutations after valid reduction to the source local +ring; equality of the coordinate maps implies equality on arbitrary input +functions. No inference from a few special Boolean data inputs is needed. + +Let a parent request be D_(gPg^-1) on the complete cover row g, and the child +canonical target be D_(hQh^-1). Push the parent's whole role fiber to h=gS, +execute the complete child and return by S^-1. Then + + (gS) Q (gS)^-1 = g P g^-1. + +Right multiplication by the invertible fixed S is a bijection of the entire +GL cover, so no arbitrary input is discarded/copied or assumed zero. Source +'gather' notation can list S^-1 for the input address lookup; our statement +uses the explicit push convention above. Both routes remain paid. + +At f1/f2, small witnesses modulo25 and49 compare the canonical routed physical +operator, applied to every linear coordinate basis vector, with a separately +implemented direct projector action. There are384 such basis-column checks. +These small rings do not replace the actual q>2^45 N^5 rule. The proof is over +the rational identities and valid local-ring reductions at every width. + +## 3. Weights, complete cover rows and real carries + +The parent's external unit weight may depend on exposed ancestor coordinates +and column index but is independent of the current fresh cover row/roles. +Its address map Lambda=diag(A,I) therefore commutes with the fiber route: +the route changes g only and Lambda has the same value before/after it. This +is an equality of two maps on the product domain, not a claim that arbitrary +matrix S commutes with a diagonal matrix A on one ARRAY. Conjugating the +whole routed word gives the requested weighted projector endpoint. + +A leaf weight can depend on the current OUTER g because that g is a spectator +ancestor of the INNER call. It must remain independent of the inner fresh row. +An inner ordinary call receives all outer row/head/type fields as complete +spectators; its own stock is disjoint. This is exactly the completed type in +P1/P2, not a heterogeneous-weight supplier assumption. The finite control uses +a nonzero address and two actual row representatives to show that a weight +illegally reading the fresh row produces unequal route/weight composites. + +Write g=g0+qG1. For a fixed rational matcher reduced modulo q^w, let +h0=(g0 S) mod q. The high-coordinate map is + + G1 -> G1 S + (g0 S-h0)/q (mod q^(w-1)). + +For each finite low type g0, every entry of G1 ranges independently over the +complete local ring; invertibility depends only on g0. Thus ordinary chunk +operations see complete ranges and all other high entries as spectators. +The carry is determined by the fixed low type and source matcher and is +charged. The code separately reconstructs this formula at w2 with nonzero +high matrix and rejects dropping its actual carry. A finite low-type +permutation is also paid; it is not an unpriced gather. + +For this S, deterministic rational elimination yields5 swaps,5 unit scalings +and14 shears, and reconstructs S in the exact chronological right-product +order. On the8-row high matrix, ONE route consequently uses40 ordinary chunk +interchanges,40 fixed unit scalings,112 linear ordered shifts and at most64 +carry shifts, plus one finite low-type permutation. Its inverse has the same +conservative counts. The PAIR ledger is80 ordinary interchanges,80 scalings, +224 linear shifts, at most128 carry shifts and2 low-type permutations. +The tensor multiplicity f does not enlarge the8-dimensional cover row. +An embedding into a fixed larger compiler N gives a finite constructive count +by the same elimination and high-row algorithm. The count depends on that +fixed program; it is not assumed uniformly constant as N changes. + +Each ordinary interchange uses the completed backend with the other high +coordinates/low type as spectators. The ordered-affine/unit-scaling primitive +cost remains inherited P2, explicitly charged. The finite low-type permutation +can be generated by a finite table/cycle decomposition, whose size is bounded +by |GL_N(F_q)|; its source physical routing implementation is retained. We +have not executed the astronomical compiled routing list or independently +proved P2's tape realization. Their charges remain finite algorithm-derived +constants, never zero. + +## 4. Weighted atoms consume exactly the available completed API + +For every unit a in a commutative source local ring, let + + J1=[0 1;1 0], L(b)=[1 0;b 1], U(a)=[1 a;0 1]. + +The exact identities are U(a)=J1 L(a) J1 and + + Ja=diag(1,-1) U(a) L(-a^-1) U(a)=[0 a;a^-1 0]. + +Consequently the chronological literal word uses4 OLD ordinary J1 calls, +3 prefix-controlled shifts and1 fixed sign. It requires no weighted backend +primitive. Every J1 exchanges two complete atom chunks with all descriptor/ +ancestor/ROW fields as spectators. Unequal inner prime is handled at the +completed ordinary endpoint, as below. The code checks this exact word over +rational units2 and3 and rejects deleting an actual J1. It does not replace +Ja by an oracle or assume differently weighted internal jobs can mix. + +## 5. Completed ordinary body and two ROW levels + +For any module of chunk coordinates and any reversal involution C, assume a +completed raw body F_n(H,D)=(C D,C H) preserves its external ROW/spectators. +Trace the actual chronological source wrapper: + + D-=H; F_n; D+=H; F_n; D=H-D. + +Starting at arbitrary H,D its states are +(H,D-H), (C(D-H),C H), (C(D-H),C D), (D,D-H), (D,H). +External fields are unchanged at every raw-call return. Three additive maps +are charged and the two completed F_n calls reuse the same restored reserve. +Their fixed multiplicity is outside the stopped recurrence, not a factor +inserted into every characteristic-moment branch. + +Borrowing is also explicit. Split the original complete argument chunks as +H=(H_hi,H_body), D=(D_hi,D_body). Reinterpret H_hi as the preceding ROW for +the ordinary body call; D_hi and original intervening Z remain spectators. +After the completed body the state is + + H_hi, D_body, Z, D_hi, H_body. + +Restore/unpad the ROW before the completed high-part interchange, then swap +H_hi,D_hi with the bodies/Z as spectators. The exact result is D,Z,H. The +borrowed high data was arbitrary original data; it was neither initialized +nor discarded. With k=ceil(log_q S(e,w))=O(w log e), k=S. Those constants +multiply only finitely in three named levels, not once per coarse recursion +node. The completed genuine-rectangle invariant permits unpadding at each +return boundary. Every initialization, retention and removal remains paid. + +The small witnesses use q5/q7,w2, padding25 to32 and49 to64, giving paired +volume ratios1024/625 and4096/2401, each<4. A row divisor3 pads the row ranges +to27 and51, charging2 owned added rows in each case. These are type fixtures, +not actual large-q compiler executions or practical stock thresholds. Replacing +the completed endpoint by the ACTUAL raw reversed binary body maps the genuine +rectangle out of itself; the rejection is not a synthetic malformed padding +label. This provides a discriminating reason the source's completed boundary +is necessary. + +## 7. Complete first-edge price type and finite chain + +No raw rank/profile changes occur. The inherited4760 caller retains11400 +original owners,57339 paid queries and7848 global helper originals; +its local supplier has436 independent helpers. +All nine paid rank7 COPY episodes per local FULL remain charged. There are +72 partial rank4 output jobs,144 added matcher routes and7548 other raw +nonidentity port routes. Their sum7692 is a RAW route census, not the count +after uniform compilation. + +Every fixed compiled matcher pair consumes its paid completed ordinary route, +fixed shifts/scalings/carries and owned movement. Every weighted leaf consumes +4 ordinary atom interchanges. Cover fallback remains paid with the source +2N^3/q fraction and up to32N^2 bad children, under the new fixed large-prime +budget. Target completion and splitting are unchanged. No new productive +credit is introduced by padding, ROW or copies. + +Set b0=.0034597,rho=.01,C1=.00347545805-(2^-36+10^-20). By P1-P3, after fixing +all new finite constants, the three root costs have the source form + + O(V[e^(1-rho) + +e^((1-rho)(1-C1)+rho(1-b0)) + +e^rho log e]). + +The middle exponent is1-a1 for a1=(1-rho)C1+rho b0. Actual computed rational +gaps establish b02^45 N^5, a compiler-size test or a stock threshold. +- Seven independent boundary controls reject an omitted matcher, omitted column + tail reversal, fresh-ROW-dependent weight, inner ROW alias, missing weighted + leaf swap, premature unpadding after the actual raw reversed body and dropped + high-matrix carry. Comparisons use coordinate actions or returned states; + they do not merely compare two copies of the asserted equality. + +The finite code corroborates the generic proof. It does not infer universal +arbitrary-input correctness solely from those22 cases. No full658/11400 RAW +native replay or astronomical compiled program was executed. + +## Complete cost boundary + +All4760 ranks remain unchanged:11400 original owners,57339 paid queries, +7848 helper originals, all nine rank7 COPY charges per local FULL retained. +The144 added partial-helper matching routes and7548 inherited port routes +remain paid; their raw total7692 is not a final compiled count. + +For the selected coarse8-dimensional matcher pair, explicit high-matrix +routing uses80 completed ordinary chunk interchanges,80 fixed unit scalings, +224 linear ordered shifts, at most128 carry shifts and2 finite low-type +permutations. Each is charged by the source fixed-rational routing primitive; +the two low-type permutations and their finite table/cycle costs remain +separate. This is a conservative constructive bound, not a practical tape +constant or a reduction of the inherited route count. For a fixed larger +compiled N, the same finite elimination/high-row algorithm gives its new +N-dependent constant before argument width varies. + +Every weighted atom uses4 completed ordinary swaps,3 controlled shifts and +1 fixed sign. Every completed ordinary body uses2 completed raw bodies and +3 additions; high-part exchange, row/radix padding, stock initialization and +removal, owned erasure, completion/splitting and full bad-class fallback remain +charged. Positive existing adapter/stock/relaxation gaps absorb fixed +constructively bounded constants, not an unknown asymptotic operation. + +Given the retained primitive bounds, the first-edge root costs remain + + O(V[e^.99 + e^(.99(1-C1)+.01(1-.0034597)) + e^.01 log e]), + +where C1=.00347545805-(2^-36+10^-20). The written proof then freezes each +backend before the next and obtains the existing finite3-level induction. +Exact Fraction checks reproduce the already declared stage gaps; no new +exponent is extracted. This validates the composition's type/cost implication +inside its conditional model, not a complete ordinary supplier implementation. + +## What still blocks full independent admission + +The actual finite native/compiler program's ROW restoration and distinct +physical allocation at all widths, the source ordered-affine/scaling/tape +implementation, generated precision/machine constants and analytic/outer +recovery remain inherited. They are explicitly P1-P3 in PROOF.md. The code +sets full4814_primitive_API_independently_proved=False. If an unconditional or +complete physical API audit is desired, it needs a literal source-bound +N-dimensional physical stock/role/route generator satisfying those premises. +Another root evaluation or this local fixture cannot supply it. + +The current positive result can strengthen the justification that4814's +conditional ordinary.003475458 uses no stronger completed interface than its +retained source allows. It cannot independently promote that record from an +archival/partially-reviewed status, prove the underlying BIT machine or raise +the global bound while the complex supplier binds. Separate4940 work remains +primary. Independent review is required before the root treats this finding +as accepted; this packet contains author checks only until that review lands. + +## Reproduction and source/credit + +Read-only from the worktree root: + + python3 -I -B outputs/bit-completed-backend-api-gate/implementation/check.py + python3 -I -O -B outputs/bit-completed-backend-api-gate/implementation/check.py + +Explicit --write writes only RESULT.json and implementation/SOURCES.json. +The script fetches immutable source Git objects; no network, primary checker +import or shared source write is performed. Normal/O stdout must match. +The formal typed inner raw contract in the fixtures is clearly labelled; +it is not a disguised claim to execute the actual full compiler. + +Credit ai-nanachi4760/4814/4326; rohanarun185/199 and Maxime Fleury204; +Cinna Davis/1337isnot1337, zxv, Jacob Alan Sussman, Mark/Matarener4697/4612, +and the retained whole-job/ROW/native/precision/tape/outer lineage. New4944 +(physically typed CRT placement) and4942 (that callee's branch threshold) +are neighboring source-bound uses, not this completed-backend proof; their +CRT layouts and threshold calculations are not repeated. Substantial OpenAI +Codex assistance, Apache-2.0. No human or proof-kernel review is claimed. diff --git a/research/bit-completed-backend-api/science/history/prior-controls/RESULT.json b/research/bit-completed-backend-api/science/history/prior-controls/RESULT.json new file mode 100644 index 0000000000..5136721f4a --- /dev/null +++ b/research/bit-completed-backend-api/science/history/prior-controls/RESULT.json @@ -0,0 +1,2498 @@ +{ + "all_width_proof": "See PROOF.md; finite fixtures are corroboration only", + "arbitrary_data_scope": "Exact coordinate operator identities + written universal permutation/interface proof; no full arrays or astronomical template executed", + "column_multiplicities": [ + 1, + 2 + ], + "controls": { + "fresh_ROW_weight": true, + "inner_ROW_alias": true, + "omit_column_tail_reversal": true, + "omit_high_matrix_carry": true, + "omit_matcher": true, + "omit_weighted_leaf_swap": true, + "premature_padding_cleanup": true + }, + "finite_levels": [ + { + "adapter_gap": "4276027093749855738909939/655360000000000000000000000", + "admitted": "8688251/2500000000", + "backend": "34597/10000000", + "exact": "2277572906250144261090061/655360000000000000000000000", + "relaxation_gap": "36106144261090061/655360000000000000000000000", + "stock_gap": "646528827093749855738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275924854968415738909939/655360000000000000000000000", + "admitted": "8688641/2500000000", + "backend": "8688251/2500000000", + "exact": "2277675145031584261090061/655360000000000000000000000", + "relaxation_gap": "38727584261090061/655360000000000000000000000", + "stock_gap": "646528724854968415738909939/655360000000000000000000000" + }, + { + "adapter_gap": "4275923832606815738909939/655360000000000000000000000", + "admitted": "1737729/500000000", + "backend": "8688641/2500000000", + "exact": "2277676167393184261090061/655360000000000000000000000", + "relaxation_gap": "12513184261090061/655360000000000000000000000", + "stock_gap": "646528723832606815738909939/655360000000000000000000000" + } + ], + "fixture_cap": 64, + "fixtures": [ + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 16, + "f": 1, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 25, + "prime": 5, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 0, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 0, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + }, + { + "ancestor": 1, + "basis_columns": 32, + "f": 2, + "g_variant": 1, + "inner_stock_borrowed_from_argument": true, + "modulus": 49, + "prime": 7, + "two_ROW_levels_preserved": true + } + ], + "full4814_primitive_API_independently_proved": false, + "matcher": [ + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "-1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "2", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + "matcher_inverse": [ + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "1/2", + "0", + "-1/4" + ], + [ + "0", + "-1/4", + "-1/4", + "0", + "1/4", + "0", + "1/2", + "-1/4" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "1/2", + "1/2", + "0", + "-1/2", + "0", + "0", + "1/2" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "-1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "1/2" + ] + ], + "native_rawbody_ROW_semantics": "Inherited premise; wrapper proof checks its exact use, not actual full compiler implementation", + "new_kappa": false, + "original_helper": 462, + "padding_fixtures": [ + { + "binary_range": 32, + "digit_width": 2, + "owned_padded_rows": 2, + "padded_row_range": 27, + "radix": 5, + "range": 25, + "row_divisor": 3, + "two_range_volume_factor": "1024/625" + }, + { + "binary_range": 64, + "digit_width": 2, + "owned_padded_rows": 2, + "padded_row_range": 51, + "radix": 7, + "range": 49, + "row_divisor": 3, + "two_range_volume_factor": "4096/2401" + } + ], + "physical_basis_columns_checked": 384, + "projector": [ + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1/2", + "1/2", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1/2", + "0", + "0", + "-1/2" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0", + "1/2" + ] + ], + "right_route_elimination_counts": { + "add": 14, + "scale": 5, + "swap": 5 + }, + "right_route_factors": [ + [ + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "2", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "2", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "-1", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "-1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "1/2", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "-2", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "-1/2", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "2" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "1/2" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "1" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ], + [ + [ + "1", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "1", + "0", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "1", + "0", + "0", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "1", + "0", + "0", + "0", + "-1" + ], + [ + "0", + "0", + "0", + "0", + "1", + "0", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "1", + "0", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "1", + "0" + ], + [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "1" + ] + ] + ], + "routing_cost_primitive": "Inherited fixed-rational ordered-affine/scaling/shift lemma; every elementary factor is charged", + "selected_record_changed": false, + "selected_route_pair_high_matrix_ledger": { + "carry_ordered_shifts_upper": 128, + "fixed_unit_scalings": 80, + "linear_ordered_shifts": 224, + "low_type_permutations": 2, + "ordinary_chunk_interchanges": 80, + "scope": "N=8 coarse head; all charged; low-type finite-permutation costs separate; tensor f does not enlarge cover row dimension" + }, + "small_fixtures": 22, + "source_frame": 506, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747", + "status": "PASS_ONE_CONDITIONAL_A0_TO_A1_API_IMPLICATION_NOT_PRIMITIVE_ADMISSION", + "weighted_leaf_fixtures": [ + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 5, + "shifts": 3, + "signs": 1, + "unit": 3 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 2 + }, + { + "ordinary_swaps": 4, + "prime": 7, + "shifts": 3, + "signs": 1, + "unit": 3 + } + ] +} diff --git a/research/bit-completed-backend-api/science/history/prior-controls/SOURCES.json b/research/bit-completed-backend-api/science/history/prior-controls/SOURCES.json new file mode 100644 index 0000000000..d1904f7c89 --- /dev/null +++ b/research/bit-completed-backend-api/science/history/prior-controls/SOURCES.json @@ -0,0 +1,15 @@ +{ + "checker_sha256": "1cd0967b2149a286f440efe6e7249ff1bdd32b0b8413036e6767dc30bc13d4b7", + "files": { + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz": "69fc50430f0062c040e0686f59ad32ee5af2387ae9a97d7d11b4af1aa994ed5b", + "research/bit-finite-ordinary-bootstrap/PROOF.md": "5cabee7e5264ab0d674d5d591b4a3880ad460a546bcf5d53067eeeb9aff68df2", + "research/bit-finite-ordinary-bootstrap/RECORD.json": "f56f53ced73cf7d9283c2a6b8e53f817403d26944d7bc353974fd41919bc91c8", + "research/bit-finite-ordinary-bootstrap/independent.py": "a1e47ce490c7b55262e78248107bc1d210182df2106ba35affc3f34e7d174d38", + "research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md": "9731b93026717f5fa15851e3633cbb4bdc76eba2bffb9d6b4a3b69f7dd502443", + "research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json": "d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010" + }, + "schema_version": 1, + "source_head": "f56ae4533a7d97d782a2c596a33fe844cd051747" +} diff --git a/research/bit-completed-backend-api/science/history/prior-controls/check.py b/research/bit-completed-backend-api/science/history/prior-controls/check.py new file mode 100644 index 0000000000..c1f1a653fb --- /dev/null +++ b/research/bit-completed-backend-api/science/history/prior-controls/check.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 +"""One source-bound conditional completed ordinary backend API gate. +No predecessor executable/price engine imported. Apache-2.0; Codex assistance. +""" +from pathlib import Path +from fractions import Fraction as F +from hashlib import sha256 +from collections import Counter +import json,subprocess,sys +HERE=Path(__file__).resolve().parent +PIN='f56ae4533a7d97d782a2c596a33fe844cd051747' +PATHS={'frames':'research/kappa-rebuild/bit/sources/pr589-regenerated/records/frames.json','word':'research/bit-compact-carrier-retirement/provider/inputs/WORD.json.gz','proof':'research/bit-finite-ordinary-bootstrap/PROOF.md','independent':'research/bit-finite-ordinary-bootstrap/independent.py','bridge':'research/kappa-rebuild/bit/DELAYED-COVER-BRIDGE.md','bit':'notes/three-stage-cover-bit.tex','rows':'notes/three-stage-cover-rows.tex','record':'research/bit-finite-ordinary-bootstrap/RECORD.json'} +def need(x,m): + if not x:raise ValueError(m) +def eye(n):return [[F(i==j)for j in range(n)]for i in range(n)] +def tr(a):return list(map(list,zip(*a))) +def mm(a,b):return [[sum((x*y for x,y in zip(r,c)),F(0))for c in zip(*b)]for r in a] +def add(a,b,k=1):return [[x+k*y for x,y in zip(r,s)]for r,s in zip(a,b)] +def inverse(a): + n=len(a);w=[list(r)+e for r,e in zip(a,eye(n))] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]);w[j],w[k]=w[k],w[j];v=w[j][j];w[j]=[x/v for x in w[j]] + for i in range(n): + if i!=j: + z=w[i][j];w[i]=[x-z*y for x,y in zip(w[i],w[j])] + return [r[n:]for r in w] +def kron(a,f):return [[a[i//f][j//f]*F(i%f==j%f)for j in range(len(a[0])*f)]for i in range(len(a)*f)] +def paired(p): + n=len(p);c=[[F(i+j==n-1)for j in range(n)]for i in range(n)];u=add(eye(n),p,-1) + return [x+y for x,y in zip(u,mm(p,c))]+[x+y for x,y in zip(mm(c,p),mm(mm(c,u),c))] +def paired_map(s): + n=len(s);z=[[F(0)]*n for _ in range(n)];c=[[F(i+j==n-1)for j in range(n)]for i in range(n)] + return [x+y for x,y in zip(s,z)]+[x+y for x,y in zip(z,mm(mm(c,s),c))] +def mod(a,m):return [[(x.numerator*pow(x.denominator,-1,m))%m for x in r]for r in a] +def mv(a,v,m):return [sum(x*y for x,y in zip(r,v))%m for r in a] +def direct_action(p,v,m): + # Independently apply the actual projector law coordinate-by-coordinate. + n=len(p);h,t=v[:n],v[n:];ph=mv(p,h,m);pct=mv(p,list(reversed(t)),m) + return [(h[i]-ph[i]+pct[i])%m for i in range(n)]+[(t[i]+ph[n-1-i]-pct[n-1-i])%m for i in range(n)] +def decompose(s): + w=[r[:]for r in s];n=len(s);ops=[] + for j in range(n): + k=next(i for i in range(j,n)if w[i][j]) + if k!=j:w[j],w[k]=w[k],w[j];ops.append(('swap',j,k,F(1))) + v=w[j][j] + if v!=1:w[j]=[x/v for x in w[j]];ops.append(('scale',j,j,1/v)) + for i in range(n): + if i!=j and w[i][j]: + z=-w[i][j];w[i]=[x+z*y for x,y in zip(w[i],w[j])];ops.append(('add',i,j,z)) + need(w==eye(n),'deterministic rational elimination') + factors=[] + for typ,i,j,z in ops: + e=eye(n) + if typ=='swap':e[i],e[j]=e[j],e[i] + elif typ=='scale':e[i][i]=1/z + else:e[i][j]=-z + factors.append(e) + out=eye(n) + for e in factors:out=mm(out,e) + need(out==s,'literal right multiplier factor order') + return ops,factors + +def wrapper(h,d,rows,raw): + # Source exact completed ordinary body; rows are read-only spectators of raw. + h=list(h);d=[y-x for x,y in zip(h,d)];h,d,r=raw(h,d,rows) + d=[x+y for x,y in zip(d,h)];h,d,r=raw(h,d,r) + d=[x-y for x,y in zip(h,d)] + return h,d,r + +def main(): + raw={k:subprocess.check_output(['git','--no-replace-objects','show',PIN+':'+p])for k,p in PATHS.items()} + need(sha256(raw['frames']).hexdigest()=='d006b3bfe0c04afecfea7aecfa59dfe4298b99501c70da3938e40289bc2f5010','actual source frame bank') + import gzip + word=json.loads(gzip.decompress(raw['word']));frame=json.loads(raw['frames'])['frames']['506'] + need(word['start'][462]==0 and word['final'][462]==506 and frame['dim']==4,'actual arbitrary helper462 rank4') + B=[[F(x)for x in r]for r in frame['B']];A=[[F(x)for x in r]for r in frame['A']] + P=mm(mm(tr(B),inverse(mm(B,tr(B)))),B);S=tr(B+A);Si=inverse(S);Q=[[F(i==j and i<4)for j in range(8)]for i in range(8)] + need(mm(P,P)==P and mm(mm(S,Q),Si)==P,'source rational idempotent and matcher') + ops,factors=decompose(S);need(all(x.denominator%5 and x.denominator%7 for r in S+Si+P for x in r),'declared fixture primes valid') + controls={};fixtures=[];basis_columns=0 + for f in (1,2): + Pf,Sf,Qf=kron(P,f),kron(S,f),kron(Q,f);n=8*f;Sfi=inverse(Sf) + need(mm(mm(paired_map(Sf),paired(Qf)),paired_map(Sfi))==paired(Pf),'actual reversed-tail all-f tensor form in fixture') + # This wrong C8 tensor I_f must fail at f2, unless accidentally symmetric. + if f==2: + wrong=[[F(i//f+j//f==7 and i%f==j%f)for j in range(n)]for i in range(n)] + need(wrong!=[[F(i+j==n-1)for j in range(n)]for i in range(n)],'wrong tail reversal distinguished') + controls['omit_column_tail_reversal']=True + for prime in (5,7): + m=prime**2 + for variant in (0,1): + g=eye(8);g[0][1]=F(variant);gi=inverse(g);h=mm(g,S) + gp=mm(mm(g,P),gi);hq=mm(mm(h,Q),inverse(h));need(gp==hq,'whole cover route g to gS correct') + need(mm(h,Si)==g,'exact row inverse return') + # A genuinely independent coordinate path: route via gS,Q then undo vs + # direct requested projector gPg^-1 on every linear coordinate basis. + routed=paired_map(kron(h,f));unroute=paired_map(kron(inverse(h),f));canonical=paired(Qf) + dp=mod(kron(gp,f),m);ri=mod(unroute,m);rc=mod(canonical,m);ro=mod(routed,m) + # Independent q-adic high-matrix route/carry, with fixed nonzero high part. + g0=mod(g,prime);G1=[[0]*8 for _ in range(8)];G1[1][0]=1 + sm=mod(S,m);slow=mod(S,prime) + gw=[[g0[i][j]+prime*G1[i][j]for j in range(8)]for i in range(8)] + direct=mod(mm(gw,sm),m);z=mm(g0,sm) + low=[[int(x)%prime for x in row]for row in z] + carry=[[(int(z[i][j])-low[i][j])//prime%prime for j in range(8)]for i in range(8)] + linear=mod(mm(G1,slow),prime) + high=[[(linear[i][j]+carry[i][j])%prime for j in range(8)]for i in range(8)] + rebuilt=[[low[i][j]+prime*high[i][j]for j in range(8)]for i in range(8)] + need(direct==rebuilt,'actual whole-cover high affine route including carry') + without=[[low[i][j]+prime*linear[i][j]for j in range(8)]for i in range(8)] + need(without!=direct,'omitting real route carry fails') + controls['omit_high_matrix_carry']=True + for ancestor in (0,1): + weights=[1+(i+ancestor)%2 for i in range(n)] + lam=eye(2*n);lami=eye(2*n) + for i,a in enumerate(weights):lam[i][i]=a;lami[i][i]=F(1,a) + lm,li=mod(lam,m),mod(lami,m) + for j in range(2*n): + v=[int(i==j)for i in range(2*n)] + lhs=mv(lm,mv(ro,mv(rc,mv(ri,mv(li,v,m),m),m),m),m) + rhs=mv(lm,direct_action(dp,mv(li,v,m),m),m) + need(lhs==rhs,'independent all-basis weighted physical helper route') + basis_columns+=1 + # Two visible ROW levels + a complete spectator, held by the raw contract. + r={'outer':(prime,variant),'inner':(ancestor,prime+1),'spectator':(3,7,11)} + x=[F(i+1)for i in range(n)];y=[F(2*i-3)for i in range(n)] + rawbody=lambda a,b,row:(list(reversed(b)),list(reversed(a)),dict(row)) + def inner_completed(a,b,row): + # Inner ROW is borrowed from the CURRENT argument's own high part, + # not a new arbitrary owner or externally supplied empty stock. + ah,bh=list(a[:1]),list(b[:1]);ar,br=list(a[1:]),list(b[1:]) + borrowed=dict(row);borrowed['borrowed_inner_ROW']=tuple(ah) + ao,bo,ret=wrapper(ar,br,borrowed,rawbody) + need(ret==borrowed,'inner completed body restores borrowed/current high ROW') + del ret['borrowed_inner_ROW'] + # One completed high-part interchange, after ROW restoration. + return bh+ao,ah+bo,ret + def nested_raw(a,b,row): + aa,bb,ret=inner_completed(a,b,row) + return list(reversed(aa)),list(reversed(bb)),ret + xo,yo,rr=wrapper(x,y,r,nested_raw) + need(xo==y and yo==x and rr==r,'completed wrapper arbitrary typed ROWs') + # The second nesting order is a control: overwrite outer row by inner. + def badbody(a,b,row): + row=dict(row);row['outer']=row['inner'];return list(reversed(b)),list(reversed(a)),row + _,_,bad=wrapper(x,y,r,badbody);need(bad!=r,'unrestored/aliased ROW control') + controls['inner_ROW_alias']=True + fixtures.append({'f':f,'prime':prime,'modulus':m,'g_variant':variant,'ancestor':ancestor,'basis_columns':2*n,'two_ROW_levels_preserved':True,'inner_stock_borrowed_from_argument':True}) + # Non-tautological fresh weight failure: the route changes the row queried + # by the illegal weight. Choose the already declared variant1, no search. + g=eye(8);g[0][1]=1;h=mm(g,S) + fresh=lambda z:1+int(z[0][1]==0) + need(fresh(g)!=fresh(h),'fresh-row weight descriptor changes on actual route') + address=[1]+[0]*15 + left=(tuple(map(tuple,h)),fresh(g)*address[0]) + right=(tuple(map(tuple,h)),fresh(h)*address[0]) + need(left!=right,'actual fresh-row scaling and route commutator on nonzero address') + controls['fresh_ROW_weight']=True + # Four OLD ordinary swaps, three shifts, one fixed sign; exact modular word. + I=eye(2);J=[[F(0),F(1)],[F(1),F(0)]] + def L(a):return [[F(1),F(0)],[F(a),F(1)]] + sig=[[F(1),F(0)],[F(0),F(-1)]];weighted=[] + for prime in (5,7): + m=prime**2 + for a in (2,3): + aa=F(a);word=[J,L(aa),J,L(-1/aa),J,L(aa),J,sig] + op=I + for e in word:op=mm(e,op) + expected=[[F(0),aa],[1/aa,F(0)]] + need(op==expected,'literal4 ordinary weighted leaf swaps') + bad=I + for k,e in enumerate(word): + if k!=0:bad=mm(e,bad) + need(bad!=expected,'omitted ordinary atom interchange') + controls['omit_weighted_leaf_swap']=True;weighted.append({'prime':prime,'unit':a,'ordinary_swaps':4,'shifts':3,'signs':1}) + # Padding uses the invariant genuine rectangle, not an assumed inverse of + # an internally uncompleted body. These address permutations are independent + # of the rational matrix helper checks above. + padding=[] + for radix in (5,7): + original=radix**2;padded=1<<(original-1).bit_length();need(padded<2*original,'two chunk binary pad bound') + genuinely=set((i,j)for i in range(original)for j in range(original));returned={(j,i)for i,j in genuinely} + need(returned==genuinely,'completed ordinary swap preserves genuine rectangle') + need(all((i=row_stock and row_padded<2*source,'owned ROW pad bound') + bits=padded.bit_length()-1 + rev=lambda n:sum(((n>>i)&1)<<(bits-1-i)for i in range(bits)) + bad={(rev(j),rev(i))for i,j in genuinely} + need(bad!=genuinely,'actual raw reversed body violates genuine padding rectangle') + controls['premature_padding_cleanup']=True + padding.append({'radix':radix,'digit_width':2,'range':original,'binary_range':padded,'two_range_volume_factor':str(F(padded**2,original**2)),'row_divisor':row_stock,'padded_row_range':row_padded,'owned_padded_rows':row_padded-source}) + # Reject omitted physical whole-job matcher with actual matrices. + controls['omit_matcher']=paired(Q)!=paired(P) + need(all(controls.values()),'every semantic control distinguishes') + C1=F('.00347545805')-F(1,2**36)-F(1,10**20);rho=F(1,100);b=F('.0034597');levels=[] + for value in (F('.0034753004'),F('.0034754564'),F('.0034754580')): + a=(1-rho)*C1+rho*b;need(b