diff --git a/research/one-query-endpoint-scan/.gitattributes b/research/one-query-endpoint-scan/.gitattributes new file mode 100644 index 0000000000..fa1385d99a --- /dev/null +++ b/research/one-query-endpoint-scan/.gitattributes @@ -0,0 +1 @@ +* -text diff --git a/research/one-query-endpoint-scan/.gitignore b/research/one-query-endpoint-scan/.gitignore new file mode 100644 index 0000000000..43ae0e2a6c --- /dev/null +++ b/research/one-query-endpoint-scan/.gitignore @@ -0,0 +1,2 @@ +__pycache__/ +*.py[cod] diff --git a/research/one-query-endpoint-scan/BINDINGS.json b/research/one-query-endpoint-scan/BINDINGS.json new file mode 100644 index 0000000000..547dcedcd6 --- /dev/null +++ b/research/one-query-endpoint-scan/BINDINGS.json @@ -0,0 +1,200 @@ +{ + "claims": [ + "C35", + "C36" + ], + "files": [ + { + "kind": "unchanged frozen source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "path": "original/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-FACTORY.json", + "path": "source/native-frames/CONJUGATED-FACTORY.json", + "sha256": "dc3a105b7ce7d226aeb8996aea6454ee66d65d9b9529af159d417f00bec02d34" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-REFLECTION.json", + "path": "source/native-frames/CONJUGATED-REFLECTION.json", + "sha256": "15980d81733f121d23f7e95f1fb50aa3dccfdc67fb79794b4a93e34f8874293f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/DUAL-REFLECTIONS.json", + "path": "source/native-frames/DUAL-REFLECTIONS.json", + "sha256": "efcdb1dc157eb0d4d3ac89b390100bc602134ae3d6d4026ce162a5af50d59b59" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/ORTHOGONAL-REFLECTION-PROOF.md", + "path": "source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md", + "sha256": "38859131f623d315144c0c7da12cf8bae81e3920f2f0d941d67bab374b6f844c" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json", + "path": "source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json", + "sha256": "7bc4603273dcd5177f01fd60c68c439fc0e5668d8e329bf24d02323c4391ea2a" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_factory.py", + "path": "source/native-frames/conjugated_factory.py", + "sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "path": "source/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/dual_reflections.py", + "path": "source/native-frames/dual_reflections.py", + "sha256": "b836c6e08e630518a4e11819e5463fc67faaa3c2fc137f13f1dc376a7f6afd82" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py", + "path": "source/native-frames/lifted_algebra.py", + "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9" + }, + { + "kind": "path-adapted source", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "path": "source/native-frames/native_model.py", + "sha256": "b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py", + "path": "source/native-frames/orthogonal_source_normalizer.py", + "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/DUAL-REFLECTION-SCREEN.json", + "path": "source/q4-pauli-fusion/DUAL-REFLECTION-SCREEN.json", + "sha256": "175f69f61b30ee941809d8f36475e62b2a27dd2aa0f8efeb44e66c56ff27df7f" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/EXTENSION-HANDOFF.md", + "path": "source/q4-pauli-fusion/EXTENSION-HANDOFF.md", + "sha256": "a6a4998aa1c3c626bc9e22473b7a557c54c0e893acab6645a73839b2e49d8650" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.json", + "path": "source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.json", + "sha256": "d238dda20ac54c87aca1e68b8489c34c052c6d7406c7ea52e0e478e604661e07" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.md", + "path": "source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.md", + "sha256": "9ca2528303f5b47ed7e21f2446ac89aec16e5973a4716169a8dc4b3ad35c6118" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/PRUNED-VARIED-REPLAY.json", + "path": "source/q4-pauli-fusion/PRUNED-VARIED-REPLAY.json", + "sha256": "f9a1d8d644c6fb46dc71ded6966a0045235d149e33c28d852b3eb869398b5276" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/UNPAIRED-REFLECTION-SCREEN.json", + "path": "source/q4-pauli-fusion/UNPAIRED-REFLECTION-SCREEN.json", + "sha256": "c1fd1811b4c49c7ce989a8b695c2b6387f162c02da3d7bf62287ccde1f96c4cb" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/VARIED-REFLECTION-SCREEN.json", + "path": "source/q4-pauli-fusion/VARIED-REFLECTION-SCREEN.json", + "sha256": "d24788becae541ef908a121395581333e7a797f30b0adc597addeda4602a3a96" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/one_query_endpoint_obstruction.py", + "path": "source/q4-pauli-fusion/one_query_endpoint_obstruction.py", + "sha256": "398ae61a6c59c86f0c41c8b2bcbdd60ce9dafacb410a3071fd68e27d427c5384" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/reflection_route_pruned.py", + "path": "source/q4-pauli-fusion/reflection_route_pruned.py", + "sha256": "63c6d8a2d6ab986138cade152b8279de20865f95dd0a2c270024c4dfd9575ae4" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/unpaired_reflection_screen.py", + "path": "source/q4-pauli-fusion/unpaired_reflection_screen.py", + "sha256": "cc385b510da37946acc0f9882f74d30f3431e8c9ef9e99dd5699aeaa81ec531e" + }, + { + "kind": "unchanged frozen input", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/varied_reflection_screen.py", + "path": "source/q4-pauli-fusion/varied_reflection_screen.py", + "sha256": "59fe8f29770c7ec7e75b5ab29716f1dd7a35404e74919e5370bc04cc2df41c86" + }, + { + "kind": "unchanged inherited implementation", + "origin": "/Users/ross/git/math/integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py", + "path": "source/vendor/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/NOTICE.md", + "path": "source/vendor/credits/NOTICE.md", + "sha256": "538e7634331d7e24791be08dedd737bf458f35a3b46ce651e6aacd905f3dee6e" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/PR533-NOTICE.md", + "path": "source/vendor/credits/PR533-NOTICE.md", + "sha256": "2c1961a07b0976e29e8e6f4da14a9aaeb2f961a3a78d842488065aa433fa2f98" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/vendor/pr531/NOTICE.md", + "path": "source/vendor/credits/vendor/pr531/NOTICE.md", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/vendor/pr531/SOURCES.json", + "path": "source/vendor/credits/vendor/pr531/SOURCES.json", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "kind": "unchanged source-specific notice/provenance", + "origin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90:research/kernel92-frame-composition/vendor/pr531/inputs/PR523-ANCESTRY.json", + "path": "source/vendor/credits/vendor/pr531/inputs/PR523-ANCESTRY.json", + "sha256": "0bfce40d86c849f18e8872ee9e8462b0a69a34ed04e01e942a6614645f686f4b" + }, + { + "kind": "unchanged inherited implementation", + "origin": "/Users/ross/git/math/.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py", + "path": "source/vendor/full_stabilizer_bound.py", + "sha256": "f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75" + } + ], + "limits": "Byte retention and replay bindings are not mathematical acceptance. Historical receipt paths and producer hashes remain original; selected entrypoints are replayed through the explicit source-byte loader.", + "original_run": "kappa-four-coordinate-20261019T0717Z", + "path_adaptations": [ + { + "adapted_sha256": "b4291b2868f91f6e77058e58e936b2efe965a9d9ae58095745fa2dad8c1d5c68", + "change": "Three source locations only: package-local BASE and immutable CE/BOUND locations. No arithmetic, assertions, constants or coverage changed.", + "original_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "path": "source/native-frames/native_model.py" + } + ], + "schema_version": 1, + "scientific_base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90" +} diff --git a/research/one-query-endpoint-scan/LICENSE b/research/one-query-endpoint-scan/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/one-query-endpoint-scan/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/one-query-endpoint-scan/NOTICE.md b/research/one-query-endpoint-scan/NOTICE.md new file mode 100644 index 0000000000..9b2e471c3f --- /dev/null +++ b/research/one-query-endpoint-scan/NOTICE.md @@ -0,0 +1,19 @@ +# Attribution and scope + +Copyright 2026 Ross Richardson. New caller derivations, exact replay adapter +and packaging: Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0, under the included LICENSE. + +The exact inherited Gaussian-dyadic compiler is not new work. The unchanged +kernel92/PR531 notices, source manifest and PR523 ancestry remain under +source/vendor/credits/. Their source authors and AI disclosures are retained. +The locally frozen predecessor proofs and mathematical scripts are retained +with original bytes and original AI assistance notices, except the explicitly +identified read-only path adaptations whose originals are also retained. + +PR3987 (Chris R / Clear1nsight) and PR4002 (ToikY) retain generic signed-lift +and phase-normalization credit. PR3989/4045 retain their separate interface +and physical-volume theorems. Separate BIT PR4021/4023 and older Ross-authored +PR3630/3632/3645/3649/3655 are prior publications, not unpublished new results. +No arithmetic, κ, selected-record or scientific-acceptance claim is imported +from a PR title, publication state, archive or source-integrity check. diff --git a/research/one-query-endpoint-scan/README.md b/research/one-query-endpoint-scan/README.md new file mode 100644 index 0000000000..0ba9c46c33 --- /dev/null +++ b/research/one-query-endpoint-scan/README.md @@ -0,0 +1,120 @@ +# One-query endpoint obstruction with a paid scan lower bound + +**Scoped caller result; no new κ or selected-frontier change.** + +## Result + +For the fixed triangular cut +`C_f=[[Q_f-I,N_f],[Q_f,0]]`, two arbitrary independent carrier banks, +and one unary query on an M-dimensional bank, fixed finite uniform-tensor +physical-monomial endpoint dictionaries cannot implement C for every f. +The proof allows arbitrary f-dependent scalar coefficients and arbitrary +query U. It uses tensor-ray separation, not false matrix independence at f=1. + +An independent support argument allows growing, nonuniform physical +monomial controllers. The actual N and all 18 admitted primal/dual Q base +operators are unitary, four-flat in every physical column, with maximum +entry modulus 1/2. Their tensor recipes therefore force endpoint column +supports `K_G K_F>=4^f`, and hence at least `a_G+a_F>=2f` scalar bank ADDs. +A paid O(f) ADD word is allowed by this bound. + +The same-size restored dirty-helper extension retains the dimension +contradiction. The separately stated variable-width extension requires +queried width `w<=M`. An arbitrarily wider queried helper is outside it. + +## Proof and exact coverage + +The [proof](source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.md) +retains the untouched-column argument, a constructive tensor-separating +polynomial and Cauchy's support-uncertainty inequality. The actual base +checker computes every Gaussian entry of all 19 native matrices and the +monomial positive control, and checks orthonormality of all 64 columns. +The replay rejects a monomial relabelled as a four-flat native and checks +the exact helper-width boundary. These controls run in both Python modes. + +The [archival search appendix](source/q4-pauli-fusion/EXTENSION-HANDOFF.md) +retains C36's repeated, varied-primal and primal/dual-routing screens, +their exact scripts and receipts: respectively `24^5`, `26^5`, `26^5` +declared five-query choices with the precise bank/route/endpoint alphabets. +All source and receipt bytes are checked, but these large searches are +**not reexecuted by the registered command**. Their historical exact +search coverage is separate from the fresh all-base Gaussian replay and +the written endpoint proofs. No general five-query impossibility is asserted. + +## Limits + +This concerns the displayed triangular C and endpoint contracts. +It does not exclude a changed carrier cut, balanced gate with a new +proof, growing paid ADD controllers, multi-bank queries, wider queried +helpers, nonmonomial free endpoints or cross-cut sharing. It is not a +full-caller stock lower bound or a new asymptotic bound. + +## Reproduce + +From the repository root, on Python 3.12: + +```sh +python3.12 -B scripts/research_package.py --package research/one-query-endpoint-scan +python3.12 -B scripts/check_research_commit.py --package research/one-query-endpoint-scan --check-source-history +``` + +The registered manifest runs `verify.py` normally and with `-O`. Its direct +portable equivalent is `python3 -B verify.py` (or `python3 -O -B verify.py`) +from this package. The direct command needs only standard-library Python, +no Git/network and no original Ross-specific directory. `--json` prints the +complete replay summary. It writes no package files. + +[BINDINGS.json](BINDINGS.json) retains every consumed original source/data +byte hash and explicitly records the path-only adaptations. Original versions +of adapted scripts remain under `original/`. Other source bytes and historical +receipts remain unchanged. Those receipts retain their old absolute provenance +paths; they are data, not required filesystem locations. The replay adapter +resolves only the explicitly retained original source inventory. Original lane +notes are archival and keep their original scope and attribution. + +The source loader hashes and compiles the **same bytes**, never loads `.pyc`, +and compiles historical implementations with `optimize=0` in both parent +Python modes, preserving inherited assertions. Mathematical receipt comparison +omits only the enumerated provenance fields in `verify.py`; all such retained +input bytes are checked separately. A changed-source control rejects. Hashes +provide integrity against the trusted publication, not external authentication +or mathematical correctness. Git/source-history, export integrity, finite +replay, written proof, hosted CI and supplier admission remain separate. + +## Related work and credit + +Ross Richardson with substantial OpenAI Codex assistance, including separate +mathematical checking contexts and this packaging adapter. No independent +human or formal-kernel review is claimed. New work is Apache-2.0. + +The Gaussian-dyadic compiler is inherited unchanged from icekylinx's PR531 +through Rohan Arun's kernel92 composition. The exact original notices and +source ancestry are retained in `source/vendor/credits/`; they preserve +DreamingOfClouds, Dugongue, eumemic and the geometry/compiler lineage. + +Chris R / Clear1nsight's PR3987 and ToikY's PR4002 retain credit for generic +native-lift phase/cocycle normalization and the need for exact signed/global +phase witnesses. This package makes no generic normalization priority claim. +Chris R's PR3989 and PR4045 are related explicit interface/volume-cost results; +their different fixed sources and theorems are neither imported nor claimed +as new here. These named overlaps were read at exact heads: + +| PR | Exact head | Contributor | +|---|---|---| +| [#3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987) | `fc536202fdaa924158789a5ef59ac079bbe21922` | Clear1nsight | +| [#4002](https://github.com/CrocSwap/integer-mult-bounds/pull/4002) | `d593941ea0a4926021cba9d01fe60500579e464f` | ToikY | +| [#4023](https://github.com/CrocSwap/integer-mult-bounds/pull/4023) | `9124007ea9029a9a3b88898bb4c350ddb27ffa58` | RossRichardson | +| [#3989](https://github.com/CrocSwap/integer-mult-bounds/pull/3989) | `7b6dda7ab6ed10d608ecba357ac2f6924166d38b` | Clear1nsight | +| [#4045](https://github.com/CrocSwap/integer-mult-bounds/pull/4045) | `91afbb643f7f4ccf6f34b685ecd959eb790a0f94` | Clear1nsight | + +[RELATED-WORK.json](RELATED-WORK.json) separately inventories the already +published PRs 3630/3632/3645/3649/3655 and separate BIT PRs 4021/4023. +Their publication is not supplier admission. This contribution neither +constructs BIT nor duplicates those results. The recent-PR/live-discussion +overlap has explicit partial coverage, not a proof of novelty. + +## Open next questions + +Can an explicit growing paid endpoint word or a multi-query changed-cut word fit a complete caller budget? Write its physical operands, exact endpoint columns and scan lengths; compare with the 2f lower bound before any all-size pricing claim. The retained fixed alphabets found no favorable word; no general search, physical admission or compatible joint supplier is supplied. +The same question, relevance, feasible first step and blockers are in +[TASK.json](TASK.json). diff --git a/research/one-query-endpoint-scan/RELATED-WORK.json b/research/one-query-endpoint-scan/RELATED-WORK.json new file mode 100644 index 0000000000..7b0b0117f0 --- /dev/null +++ b/research/one-query-endpoint-scan/RELATED-WORK.json @@ -0,0 +1,95 @@ +{ + "scientific_base": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "priority_revision": 6, + "coverage": "Exact named PR head/body reads plus parent recent80-open-PR and partial live Discussion delta; not exhaustive code/closed/unpublished overlap.", + "pull_requests": [ + { + "number": 3987, + "title": "Audit staged544 native phases and expose the binary-inverse lift defect", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3987", + "head": "fc536202fdaa924158789a5ef59ac079bbe21922", + "author": "Clear1nsight", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4002, + "title": "Derive explicit native-lift phase tags and signed-word certificates", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4002", + "head": "d593941ea0a4926021cba9d01fe60500579e464f", + "author": "ToikY", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4023, + "title": "Prove sharp fixed-support unary-query bounds with restored dirty banks", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4023", + "head": "9124007ea9029a9a3b88898bb4c350ddb27ffa58", + "author": "RossRichardson", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 3989, + "title": "Construct selected rank-two Pauli fusion and bound its uniform transfer bill", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3989", + "head": "7b6dda7ab6ed10d608ecba357ac2f6924166d38b", + "author": "Clear1nsight", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4045, + "title": "research: bind joint-child batching to the staged544 native rank interface", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4045", + "head": "91afbb643f7f4ccf6f34b685ecd959eb790a0f94", + "author": "Clear1nsight", + "scope": "Related phase/interface result; not rerun or claimed here." + }, + { + "number": 4021, + "title": "Verify five rank-four BIT terminals and their fixed-controller cost bound", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/4021", + "head": "c01f97ecfc7fa64847f6abd8f7b231e1df8c7b70", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3630, + "title": "Bound staged-supplier packing for every replica count", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3630", + "head": "bcac7fe04b9b7f7f5d3c27d620561f96c4ae5608", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3632, + "title": "Correct the selected P112 scatter covariance and dirty restoration", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3632", + "head": "7e7a889cbf6da2c4461af806fe52a888c621a7e7", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3645, + "title": "Reduce R438 to 429 helpers with three source snapshots", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3645", + "head": "99b901c9b5ac70cf441b3d7e585cc7b8744b5359", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3649, + "title": "Classify sharp noncubic ranks of the H6 odd-Gram family", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3649", + "head": "f8768756d8ac4abb263295170a436ba54562fdcd", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + }, + { + "number": 3655, + "title": "Classify H6 dyadic Smith factors and sharp physical-row repair", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/3655", + "head": "7bf23e128e58a33c019268f57129629f603547f7", + "author": "RossRichardson", + "scope": "Already published separate BIT/prior lineage; excluded from this new contribution." + } + ] +} diff --git a/research/one-query-endpoint-scan/SOURCES.json b/research/one-query-endpoint-scan/SOURCES.json new file mode 100644 index 0000000000..68bddcb9b4 --- /dev/null +++ b/research/one-query-endpoint-scan/SOURCES.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py", + "usage": "provenance", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kernel92-frame-composition/NOTICE.md", + "usage": "provenance", + "git_blob": "8d3c3349e13774de4f992591c3a0b9e74029f761", + "sha256": "538e7634331d7e24791be08dedd737bf458f35a3b46ce651e6aacd905f3dee6e" + }, + { + "path": "research/kernel92-frame-composition/PR533-NOTICE.md", + "usage": "provenance", + "git_blob": "6e6d0042d1cf618308e7e57df3e7e8b6958991d0", + "sha256": "2c1961a07b0976e29e8e6f4da14a9aaeb2f961a3a78d842488065aa433fa2f98" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/NOTICE.md", + "usage": "provenance", + "git_blob": "f7a8f861be860edd5a78114c5225dec90effa029", + "sha256": "a92f49c5ced455160fbedcc8954e3c9255e3605e88ad12ae5a84f1c4302986f1" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/SOURCES.json", + "usage": "provenance", + "git_blob": "78244052aae4866ae9e8e2d2e4c10180870a0fc4", + "sha256": "9e8182e6e659f4671fe0873e324b622cc871df7344157093df40476c8687be5f" + }, + { + "path": "research/kernel92-frame-composition/vendor/pr531/inputs/PR523-ANCESTRY.json", + "usage": "provenance", + "git_blob": "385a202fbc485ceaed1b604d6c21eb3486caa600", + "sha256": "0bfce40d86c849f18e8872ee9e8462b0a69a34ed04e01e942a6614645f686f4b" + }, + { + "path": "LICENSE", + "usage": "provenance", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } + ] +} diff --git a/research/one-query-endpoint-scan/TASK.json b/research/one-query-endpoint-scan/TASK.json new file mode 100644 index 0000000000..aec50676f1 --- /dev/null +++ b/research/one-query-endpoint-scan/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one selected supplier obligation follow from its actual source-bound checks?", + "starting_points": [ + "certificates/selected-result.json", + "research/owner-boundary-audit/README.md", + "research/scatter-export-parity-audit/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 #2977 reported duplicate-scatter counterexample and its opt-in repair. The archive is not a production fix or an independently validated selected-result failure; the selected generator emits unique rows.", + "scope": "Source-binding orientation only; does not replay or validate the reported bug." + }, + "first_experiment": "First check whether the scatter repair has been adopted. If still open, independently reproduce #2977 symbolic-versus-exported parity on the tiny duplicate fixture, compare the selected unique-row positive control, and define either enforced uniqueness or consistent multiplicity semantics. A bounded guard-adoption patch must preserve valid inputs and test the actual exported action. Stop after this obligation; no full historical replay or frontier change follows from the mutant alone.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "Audit one named current condition using a new semantic counterexample." + ], + "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." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics" + ] + }, + "scope_status": "changed", + "actual_scope": "Prove two all-size one-query obstructions for the fixed triangular two-carrier map, verify the actual Gaussian native amplitude, retain the precise restored-helper width boundary, and archive the named five-query search results without enlarging their scope.", + "scope_change_reason": "Explicit donor-assigned caller investigation and authorized publication of the frozen preceding-run results; this is not a claim to solve the full original card.", + "bottleneck_link": "Complete native caller charge and original-input reader/cleanup obligations. No selected result or new kappa.", + "budget_minutes": 240, + "stop_rule": "Publish only exact complete local identities, scoped proofs or explicitly archived finite screens. Stop favorable-supplier claims at the unresolved full-bill and physical-admission boundaries.", + "outcome": "partial", + "evidence": "README.md; source proof links; BINDINGS.json; explicit normal/optimized VERIFY.json commands.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance across the original construction, separate mathematical checking contexts, and publication packaging. AI review is not independent human or formal-kernel acceptance.", + "open_questions": [ + { + "question": "Can an explicit growing paid endpoint word or a multi-query changed-cut word fit a complete caller budget?", + "why_it_matters": "This is the remaining constructive gap between the scoped result and a useful complete caller.", + "first_step": "Write its physical operands, exact endpoint columns and scan lengths; compare with the 2f lower bound before any all-size pricing claim.", + "blocked_by": "The retained fixed alphabets found no favorable word; no general search, physical admission or compatible joint supplier is supplied." + } + ] +} diff --git a/research/one-query-endpoint-scan/VERIFY.json b/research/one-query-endpoint-scan/VERIFY.json new file mode 100644 index 0000000000..dcd98d89ff --- /dev/null +++ b/research/one-query-endpoint-scan/VERIFY.json @@ -0,0 +1,28 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Complete listed operator/receipt replays and named rejecting controls; source-bound exact bytes with historical assertions enabled." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Same mathematical coverage under optimized parent Python; historical source assertions deliberately retained by optimize=0 compilation." + } + ] +} diff --git a/research/one-query-endpoint-scan/original/native-frames/native_model.py b/research/one-query-endpoint-scan/original/native-frames/native_model.py new file mode 100644 index 0000000000..03925dd36e --- /dev/null +++ b/research/one-query-endpoint-scan/original/native-frames/native_model.py @@ -0,0 +1,67 @@ +"""Pinned Gaussian Clifford model for common2/fresh2 native bridges. +Apache-2.0; substantial OpenAI Codex assistance. Frozen imports are read only. +""" +from pathlib import Path +import hashlib,importlib.util,sys +sys.dont_write_bytecode=True +BASE=Path('/Users/ross/git/math') +PIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90' +CE_PATH=BASE/'integer-mult-bounds/research/kernel92-frame-composition/vendor/pr531/vendor/clifford/clifford_exact.py' +CE_SHA='2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' +BOUND_PATH=BASE/'.research-automation/runs/kappa-changed-endpoints-20261019T0153Z/stabilizer-escape/full_stabilizer_bound.py' +BOUND_SHA='f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75' +def need(ok,why): + if not ok:raise ValueError(why) +def load(name,path,sha): + need(hashlib.sha256(path.read_bytes()).hexdigest()==sha,'source pin '+str(path)) + spec=importlib.util.spec_from_file_location(name,path);mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod +ce=load('native_frames_pinned_clifford',CE_PATH,CE_SHA) +b=load('native_frames_frozen_independent',BOUND_PATH,BOUND_SHA) +def mul(*ops):return b.standard_product(ce,*ops) +def same(a,c,why,phase=True): + need(a.tab==c.tab,why+' signed tableau') + if phase:need(b.sparse_column(a)==b.sparse_column(c),why+' actual Gaussian phase') +def phase(n,p):return ce.Op(n,ce.identity(n),[('phase',p%4)]) +def symplectic_defect_rank(op): + return b.binary_rank(x^y for x,y in zip(b.binary_tableau(op),b.binary_tableau(ce.ident(op.n)))) +def pauli(n,x=0,z=0,p=0): + out=ce.diag(n,[0]*n,[2*((z>>j)&1)for j in range(n)]) + return mul(phase(n,p),ce.xgate(n,x),out) +def conjugated_pauli(op,x=0,z=0,p=0): + triple=ce.apply(op.tab,(x,z,p));return pauli(op.n,*triple),triple +class Model: + def __init__(self,f=1,stages=4): + need(f>=1 and stages>=1,'positive chunk/stages');self.f=f;self.stages=stages;self.n=(2+2*stages)*f;self.I=ce.ident(self.n) + self.N=self.Npair(0,1);self.U=self.Hp(0);self.V=mul(self.N,self.U.adjoint()) + self.P=[self.swap_pair(s+1)for s in range(stages)];self.T=[self.Npair(2+2*s,3+2*s)for s in range(stages)] + self.Q=ce.xgate(self.n,1) + def Hp(self,chunk): + out=self.I + for j in range(self.f): + bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2 + out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<=4,'pqqp uses4 stages');gs=[self.I,self.I];controls=[];F=self.I + for s,(kind,W) in enumerate(zip('FGFG',[self.U,self.V,self.V,self.U])): + required=self.phi(gs[1])if kind=='F'else mul(W,self.N.adjoint(),gs[1],self.N,W.adjoint()) + L=mul(required,gs[0].adjoint());controls.append(L);gs[0]=required + if kind=='F':gs=[gs[0],mul(W,self.P[s],gs[1],W.adjoint())] + else:gs=[mul(W.adjoint(),gs[0],W),mul(self.P[s],gs[1])] + F=mul(self.T[s],F) + return gs,controls diff --git a/research/one-query-endpoint-scan/source/native-frames/CONJUGATED-FACTORY.json b/research/one-query-endpoint-scan/source/native-frames/CONJUGATED-FACTORY.json new file mode 100644 index 0000000000..a53882c953 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/CONJUGATED-FACTORY.json @@ -0,0 +1,140 @@ +{ + "COPY_precision_tape_obligations": "Native lowering is a Fourier/supplier query with arbitrary input. Any source COPY to a fanout, all bank reads, the two monomial ADDRESS/phase adapters, their reversible scans, precision/rounding propagation, source-bound block norms, and physical tape return remain paid caller obligations. No endpoint, all-size recursion, stock or exponent follows from this unary identity.", + "actual_checks": [ + { + "actual_native_recipe_phase": true, + "f": 1, + "inverse": "same operator", + "ranks_P2_RP2_P2R_RP2R": [ + 4, + 4, + 4, + 2 + ] + }, + { + "actual_native_recipe_phase": true, + "f": 2, + "inverse": "same operator", + "ranks_P2_RP2_P2R_RP2R": [ + 8, + 8, + 8, + 4 + ] + }, + { + "actual_native_recipe_phase": true, + "f": 3, + "inverse": "same operator", + "ranks_P2_RP2_P2R_RP2R": [ + 12, + 12, + 12, + 6 + ] + } + ], + "all_f_proof": "P2_f and R_f are bitwise tensors. Global N_f phases cancel in conjugation, so B_f=B_1^tensor f. The explicit actual one-bit equality B_1=L C_2 R_adapter tensor-lifts with fixed bitwise ADDRESS/quadratic-phase controllers to one selected native2f query. B_1 has B-rank2, so B_f has exact B-rank2f, including all f-dependent adapter phase powers.", + "caller_obligation": "This bill applies only to the literal B shown. An outgoing source P2 is not replaced for free. R uses the stage2-future plane2, so supplying both R sides at a legal caller cut with all source/target columns and fresh coverage is a separate obligation. A global chart change also transports N and cannot be used to claim this saving while holding N fixed.", + "complete_unary_invoice": { + "ADDRESS_scans_at_most": 2, + "Gaussian_quadratic_phase_scans_at_most": 2, + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "evidence_domain": "Written exact all-f tensor proof, actual Gaussian recipe and phase checks f1/f2/f3, and one-sided negative controls. No finite-f extrapolation and no formal-kernel claim.", + "exact_operator": "B=N0 R P2 R N0^-1, P2=SWAP(plane0,plane2), R=ADDRESS(I+vv^T), v=(p0,q0,p1,p2).", + "no_new_kappa": true, + "one_bit_selected_native_recipe": { + "left": { + "linear_Z4": [ + 3, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 3, + 3, + 0, + 0 + ], + "matrix_rows": [ + 37, + 48, + 2, + 36, + 8, + 52, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 48, + 0, + 48, + 0, + 21, + 37, + 0, + 0 + ] + } + }, + "producer_sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py", + "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + } + ], + "status": "PASS_ALL_F_TWO_SIDED_REFLECTION_FACTORY_SINGLE_CHILD" +} diff --git a/research/one-query-endpoint-scan/source/native-frames/CONJUGATED-REFLECTION.json b/research/one-query-endpoint-scan/source/native-frames/CONJUGATED-REFLECTION.json new file mode 100644 index 0000000000..ea17f03e16 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/CONJUGATED-REFLECTION.json @@ -0,0 +1,387 @@ +{ + "actual_operator": "R=P_(I+vv^T), v=(1,1,1,0,1,0) on completed(p0,q0,p1,q1,p2,q2); A=N0 R N0^-1.", + "actual_tensor_recipe_checks": [ + { + "conjugating_old_plane": 0, + "f": 1, + "inverse": "same A", + "native_arity": 2, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 1, + "f": 1, + "inverse": "same A", + "native_arity": 2, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 2, + "f": 1, + "inverse": "same A", + "native_arity": 2, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 0, + "f": 2, + "inverse": "same A", + "native_arity": 4, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 1, + "f": 2, + "inverse": "same A", + "native_arity": 4, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 2, + "f": 2, + "inverse": "same A", + "native_arity": 4, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 0, + "f": 3, + "inverse": "same A", + "native_arity": 6, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 1, + "f": 3, + "inverse": "same A", + "native_arity": 6, + "tensor_recipe_actual_Gaussian_phase": true + }, + { + "conjugating_old_plane": 2, + "f": 3, + "inverse": "same A", + "native_arity": 6, + "tensor_recipe_actual_Gaussian_phase": true + } + ], + "all_f_tensor_identity": "R_f is the bitwise tensor product of R_1. N_f=i^(1-f) N_1^tensor f after regrouping address coordinates. Its global unit cancels in conjugation, so A_f=A_1^tensor f literally, including phase. Tensoring the explicit one-bit monomial/native/monomial equality therefore gives A_f=L_f C_(2f) R_f_adapter. All three factors have fixed bitwise controllers; no f1 tableau-only inference is used.", + "evidence_domain": "Written all-f exact tensor proof and native B-rank proof; independent actual Gaussian compiled checks at f1/f2/f3; all-f two-bank polynomial coefficients checked in the phase-sensitive tensor algebra.", + "limits": [ + "This is a changed legal local bridge, not a completed caller or shared-debt cancellation.", + "The source-kernel N0R is not assumed quadratic, and no old scalar caller is imported by that assumption.", + "All bank ADD, ADDRESS and phase scans are paid; no source access, owner, precision, all-size or tape gate is discharged." + ], + "native_model_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "native_rank_proof": "The binary B block of A_1 has rank2. Direct sums under bitwise tensor regrouping have rank2f, so A_f and its inverse have exact native arity2f for every f>=1. A_f^2=I by conjugation of R_f^2=I.", + "no_new_kappa": true, + "old_plane_extension": "The same exact single-child admission holds for A_i=N_i R N_i^-1 on each i=0,1,2, with the three explicit recipes retained. Since N_i=i H_i and H_i=Hp_i Hq_i is involutive, this is also H_i R H_i without any external i. The tensor proof and all adapter phase powers apply separately to each saved recipe.", + "one_bit_selected_native_recipe": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 2, + 9, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 21, + 7, + 3, + 20, + 8, + 32, + 64, + 128 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 18, + 0, + 0, + 0 + ] + } + }, + "one_bit_selected_native_recipes_by_old_plane": [ + { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 2, + 9, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 21, + 7, + 3, + 20, + 8, + 32, + 64, + 128 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 18, + 0, + 0, + 0 + ] + } + }, + { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 1, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 7, + 17, + 18, + 8, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 2, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 19, + 5, + 6, + 8, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + } + ], + "producer_sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f", + "reflection_source_sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "single_unary_invoice": { + "ADDRESS_scans_at_most": 2, + "Gaussian_quadratic_phase_scans_at_most": 2, + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "status": "PASS_ALL_F_SINGLE_CHILD_CONJUGATED_UNPAIRED_REFLECTION", + "two_bank_identity": "For E12=I+e1e2^T and B_R=E12 diag(I,R) E12^-1, Ad_(diag(N,N))(B_R)=E12 diag(I,A) E12^-1. Both independent inputs are retained. Its literal inverse reverses the shears and applies A^-1=A; the entire displayed conjugated word is itself involutive.", + "two_bank_invoice": { + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0, + "scalar_ADD_scans": 2 + } +} diff --git a/research/one-query-endpoint-scan/source/native-frames/DUAL-REFLECTIONS.json b/research/one-query-endpoint-scan/source/native-frames/DUAL-REFLECTIONS.json new file mode 100644 index 0000000000..e1fa1cabf0 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/DUAL-REFLECTIONS.json @@ -0,0 +1,1404 @@ +{ + "actual_checks": [ + { + "all18_native_recipes_phase_exact": true, + "all3_native_commutations_phase_exact": true, + "all3_primal_dual_intertwiners_phase_exact": true, + "each_conjugate_arity": 2, + "f": 1, + "role_duality_native_arity": 0 + }, + { + "all18_native_recipes_phase_exact": true, + "all3_native_commutations_phase_exact": true, + "all3_primal_dual_intertwiners_phase_exact": true, + "each_conjugate_arity": 4, + "f": 2, + "role_duality_native_arity": 0 + }, + { + "all18_native_recipes_phase_exact": true, + "all3_native_commutations_phase_exact": true, + "all3_primal_dual_intertwiners_phase_exact": true, + "each_conjugate_arity": 6, + "f": 3, + "role_duality_native_arity": 0 + } + ], + "all_f_bare_phase_proof": "For any even-weight support v, put c=sum_p v-sum_q v and d_v=sum_selected_p x-sum_selected_q x. On v.x=1, D^-1 P_(I+vvT) D has phase i^(2d_v-c)=-i^-c. For threep+oneq c=2, or onep+threeq c=-2, this phase is+1. Hence all6 reflections are bare ADDRESS for every f, bitwise. Each is orthogonal/involutive and normalizes the complete oldthreeplane product.", + "all_f_native_recipe_proof": "Each A_i,j family is a bitwise tensor of its actual one-bit operator: the global scalar of Ni cancels in conjugation. Tensor each saved monomial/native/monomial equality, including f times each monomial globalphase, to obtain one selected native2f child. The binary B block is a direct sum of f rank2 blocks. The f1/f2/f3 compiled recipe comparisons additionally check actual Gaussian phase.", + "conjugate_duality": "Ad_Ni(S_j)=M Ad_Ni(R_j) M. Thus duals have the same native2f tariff. M can be composed into the existing left/right monomial adapters, not treated as an unpriced operation. The separately saved recipes directly lower all18 cases.", + "dual_supports": [ + [ + 1, + 3, + 5, + 0 + ], + [ + 1, + 3, + 5, + 2 + ], + [ + 1, + 3, + 5, + 4 + ] + ], + "limits": [ + "No five-query complete diag(E3,E3) factorization or improved tail is claimed here.", + "Scalar, conditional-routing, bank ADD, source-copy, address, phase, precision and tape work remain caller obligations.", + "The global duality restricted to old3planes need not commute a future whole-plane source swap; do not silently push it through a later sourcePj." + ], + "no_new_kappa": true, + "one_bit_selected_native_recipes": { + "dual_reflection0_conjugating_plane0": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 2, + 8, + 17, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 41, + 11, + 3, + 4, + 40, + 16, + 64, + 128 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 0, + 34, + 0, + 0, + 0, + 34, + 0, + 0 + ] + } + }, + "dual_reflection0_conjugating_plane1": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 1, + 32, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 35, + 11, + 33, + 34, + 4, + 16, + 64, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "dual_reflection0_conjugating_plane2": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 16, + 2, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 11, + 35, + 9, + 10, + 4, + 16, + 64, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "dual_reflection1_conjugating_plane0": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 2, + 9, + 17, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 44, + 1, + 36, + 40, + 16, + 64, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "dual_reflection1_conjugating_plane1": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 17, + 1, + 32, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 14, + 38, + 1, + 34, + 12, + 16, + 64, + 128 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 40, + 0, + 40, + 0, + 0 + ] + } + }, + "dual_reflection1_conjugating_plane2": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 18, + 2, + 32, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 14, + 38, + 1, + 10, + 12, + 16, + 64, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "dual_reflection2_conjugating_plane0": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 2, + 8, + 17, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 26, + 56, + 1, + 4, + 40, + 48, + 64, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "dual_reflection2_conjugating_plane1": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 1, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 2, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 50, + 26, + 1, + 34, + 4, + 48, + 64, + 128 + ], + "offset": 0, + "phase": 3, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "dual_reflection2_conjugating_plane2": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 4, + 10, + 16, + 2, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 50, + 26, + 1, + 10, + 4, + 48, + 64, + 128 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 40, + 0, + 40, + 0, + 0 + ] + } + }, + "primal_reflection0_conjugating_plane0": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 2, + 9, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 21, + 7, + 3, + 20, + 8, + 32, + 64, + 128 + ], + "offset": 2, + "phase": 0, + "quadratic_rows": [ + 0, + 18, + 0, + 0, + 18, + 0, + 0, + 0 + ] + } + }, + "primal_reflection0_conjugating_plane1": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 1, + 16, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 19, + 7, + 17, + 18, + 8, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "primal_reflection0_conjugating_plane2": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 10, + 2, + 16, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 7, + 19, + 5, + 6, + 8, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "primal_reflection1_conjugating_plane0": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 17, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 28, + 2, + 20, + 24, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "primal_reflection1_conjugating_plane1": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 17, + 1, + 2, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 21, + 17, + 2, + 12, + 32, + 64, + 128 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 24, + 24, + 0, + 0, + 0 + ] + } + }, + "primal_reflection1_conjugating_plane2": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 18, + 2, + 1, + 32, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 2, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 13, + 21, + 9, + 2, + 12, + 32, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "primal_reflection2_conjugating_plane0": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 2, + 4, + 9, + 16, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 2, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 21, + 52, + 2, + 36, + 8, + 48, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "primal_reflection2_conjugating_plane1": { + "left": { + "linear_Z4": [ + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 1, + 16, + 34, + 2, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 2, + 0, + 0, + 0, + 2, + 0, + 0, + 0 + ], + "matrix_rows": [ + 49, + 21, + 33, + 2, + 8, + 48, + 64, + 128 + ], + "offset": 3, + "phase": 1, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + } + }, + "primal_reflection2_conjugating_plane2": { + "left": { + "linear_Z4": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "matrix_rows": [ + 6, + 8, + 2, + 16, + 33, + 1, + 64, + 128 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "rank": 2, + "right": { + "linear_Z4": [ + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0 + ], + "matrix_rows": [ + 49, + 21, + 5, + 2, + 8, + 48, + 64, + 128 + ], + "offset": 1, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 36, + 0, + 0, + 36, + 0, + 0 + ] + } + } + }, + "per_conjugate_unary_invoice": { + "ADDRESS_scans_at_most": 2, + "Gaussian_quadratic_phase_scans_at_most": 2, + "monomial_adapters": 2, + "native_H2": 1, + "native_rank_mass": 2, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "per_reflection_source_invoice": { + "delivery_ADD_scans": 1, + "native_H2": 2, + "native_rank_mass": 4, + "new_reflection_ADDRESS_scans": 2, + "new_reflection_phase_scans": 0, + "ordinary_helpers": 0, + "private_fields": 0, + "source_Pj_ADDRESS_scans": 1 + }, + "primal_supports": [ + [ + 0, + 2, + 4, + 1 + ], + [ + 0, + 2, + 4, + 3 + ], + [ + 0, + 2, + 4, + 5 + ] + ], + "producer_sha256": "b836c6e08e630518a4e11819e5463fc67faaa3c2fc137f13f1dc376a7f6afd82", + "role_duality": "M=product_i[Z_all_p_i Z_all_q_i SWAP(p_i,q_i)]. The exact typed identities are Z_all Hp_f Z_all=(-i)^f Hq_f and Z_all Hq_f Z_all=i^f Hp_f. Their scalars cancel inside each plane, giving M Ni M=Ni with its one global i retained. M^2=I. Swapping everyp/q exchanges primal anddual supports; Z_all_old commutes these even-weight orthogonal maps, so M R_j M=S_j with no residual scalar or Pauli.", + "role_duality_standalone_invoice": { + "ADDRESS_scans": 1, + "Pauli_Z_scans": 1, + "native_queries": 0 + }, + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_binding": "Any of the6 reflections can be inserted with its inverse around delivery at a source full-old cut containing its3planes. The complete arbitrary-source/target matrix and literal inverse are those of UNPAIRED-SOURCE-WORD.json by the same full-old commutation identity; sourcePj and freshcoverage remain unchanged. This does not make reflection a free outgoing source code change.", + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/orthogonal_source_normalizer.py", + "sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/lifted_algebra.py", + "sha256": "3b9a58a2048a762ab520ac7fdbb28cbfeb7b30345aaeb777d8dabdd9fb1034d9" + } + ], + "status": "PASS_ALL_F_DUAL_UNPAIRED_REFLECTIONS_AND_18_NATIVE_RECIPES" +} diff --git a/research/one-query-endpoint-scan/source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md b/research/one-query-endpoint-scan/source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md new file mode 100644 index 0000000000..d6c9c0c46e --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/ORTHOGONAL-REFLECTION-PROOF.md @@ -0,0 +1,105 @@ +# An unpaired exact ADDRESS normalizer and its common conjugate + +Source pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. The scripts +`orthogonal_source_normalizer.py` and `conjugated_reflection.py` preserve +their native source/compiler hashes in their JSON receipts. + +Credit and overlap: the generic even-linear lift/cocycle warning belongs +to Chris R / Clear1nsight's [PR3987](https://github.com/CrocSwap/integer-mult-bounds/pull/3987), +head `fc536202fdaa924158789a5ef59ac079bbe21922`. ToikY's +[PR4002](https://github.com/CrocSwap/integer-mult-bounds/pull/4002), head +`d593941ea0a4926021cba9d01fe60500579e464f`, gives exact normalized lifts, +signed words and mandatory anticommuting-C phase tags. The typed +`P_A Z_z` specialization here is not claimed as a new generic +normalization theorem. The distinct local obligation is its actual typed +source cut, full independent columns and inverse, native-cut rank, +fresh-progress tradeoff, and fully paid caller resource. The overlap was +read from the root's saved 10:32 board intake; no scientific pin is moved. + +For j completed old planes, with p/q chunks of length f in each plane, +let D multiply an address by `i^(sum p bits - sum q bits)`. The actual +old native product is exactly + + G_old = product_(l=0..j-1) N_l = i^j D^-1 H_all D. + +Here H_all is ordinary normalized Walsh. On one bit, +`Hp=e^(-i pi/4) S^-1 H S` and `Hq=e^(+i pi/4) S H S^-1`. +The non-Gaussian scalars cancel within every p/q pair; each N_l retains +its one literal i. Thus the displayed identity has no missing f phase. + +For any binary orthogonal A (`A^T A=I`), its literal ADDRESS operator P_A +commutes with Walsh, as follows directly from the kernel `(-1)^(x.y)`. +Consequently `R_A=D^-1 P_A D` is an exact monomial normalizer of G_old +for every f. This establishes native admission with explicit Gaussian +phases, without relying on a finite tableau to certify a tensor family. + +The useful choice needs three complete old planes. Order their six chunks +as `(p0,q0,p1,q1,p2,q2)`, and put + + v=(1,1,1,0,1,0), A=I+v v^T. + +Its weight is four, so `v^T v=0`, `A^2=A^T A=I`. The same binary map is +applied separately at every bit position. Write d(x) for the typed p-minus-q +weight and d_v for its restriction to the support of v. If `v.x=1`, then + + d(x)-d(Ax)=2 d_v(x)-2 = 0 mod 4; + +if `v.x=0`, the difference is zero. Therefore the useful normalizer is +**literally bare ADDRESS**: `R_A=P_A`. No Gaussian phase scan is needed. +It is involutive and uses only completed old coordinates. + +At stage j>=3, put Fpast equal to the completed fresh product and Fnew to +the product after the new fresh plane. Starting with two arbitrary fields +in the common Fpast chart, the literal word is + + source=N0 source; source=R source; target+=source; + source=R^-1 source; source=Pj source; target=Tj target. + +Because `[R,N0 Fpast]=0`, its full two-column matrix is exactly + + Fnew * [[Pj,0],[N0 R,I]]. + +The source code Pj, raw target coefficient, source cross coefficient, and +fresh coverage are retained, with phase. The inverse reverses the word, +uses target subtraction, and inverts each unary operator; it requires no +zero field or helper. Its bill is the original two native-2f queries, one +delivery ADD and one source ADDRESS, plus two ADDRESS R scans. Both new +scans are paid. This is a changed cross kernel, not a completed caller. + +This R escapes the old whole-plane marked-residual proof. In the physical +X-character basis it takes the character with all q0 bits set to the +character with all p0,p1,p2 bits set. Thus a configuration with one marked +plane residual is sent to three marked residuals, for every f. The actual +64-point character sum at f=1 gives coefficient exactly +1, and the written +bitwise identity gives the all-f lift. Pair-gauge phases cannot remove +nonzero leakage. + +By contrast the balanced support `(p0,q0,p1,q1)` is a negative control. +Its typed R is `Z_v P_A`; on characters it maps +`w -> w+(v.w+1)v`. With the residual mark `(p=0,q=1^f)`, it fixes an owner +inside its support and flips only unmarked virtual bits when the owner is +outside. It commutes with the marked C. The balanced reflection must not +be promoted as an escape. Its quartic kernel check is distinct from the +unpaired kernel; no claim `(N0 R)^2=-I` is made for the useful R. + +There is a further cheaper conjugation resource. Let `A_f=N0 R N0^-1`. +The global factor in `N_f=i^(1-f) N_1^tensor f` cancels in conjugation, +so `A_f=A_1^tensor f` after bitwise regrouping. The one-bit A has native +B-rank two. Its exact selected-native lowering is saved in +`CONJUGATED-REFLECTION.json`; tensoring the literal monomial/native/ +monomial equality implements A_f with one native-2f child and two fixed +bitwise monomial adapters, not two N queries. Its B-rank is exactly 2f, +and `A_f^2=I`. ADDRESS and quadratic Gaussian phase scans for both adapters +remain paid. The direct actual recipe checks cover f=1,2,3, including +global phase, while the tensor proof covers every f>=1. + +In particular, with scalar bank shear E12 and +`B_R=E12 diag(I,R) E12^-1`, + + Ad_diag(N,N)(B_R) = E12 diag(I,A_f) E12^-1. + +The right side costs one H2, two scalar ADD scans and the two monomial +adapters. Both independent bank columns and the literal inverse are +checked in the phase-sensitive tensor algebra. This does not itself +cancel a persistent factory or establish a supplier, stock surplus, +all-size transfer, precision bound, owner allocation, or tape bound. diff --git a/research/one-query-endpoint-scan/source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json b/research/one-query-endpoint-scan/source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json new file mode 100644 index 0000000000..6bb64c44d0 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/ORTHOGONAL-SOURCE-NORMALIZER.json @@ -0,0 +1,164 @@ +{ + "all_parameter_schema": "For j old native planes (2j chunks), put D=diag phasei on everyoldp bit and-i on everyoldq bit. Exact G_old=product(N_i)=i^j D^-1 H_all D. If binaryA is orthogonal,A^T A=I, then its literal ADDRESS permutation P_A commutes ordinary WalshH_all. Hence R_A=D^-1 P_A D is monomial and commutesG_old, including all global phases, for every f>=1.", + "evidence_domain": "Written all-j/all-f orthogonal conjugation proof and explicit all-f bare-phase/leakage proof; actual Gaussian phase/source-column checks for pairedj2 f1/f2/f3 and unpairedj3 f1/f2; independent64-point actual Fourier-character sums. The paired candidate is correctly rejected as a marked-C escape. No f1-only native admission is extrapolated.", + "explicit_unpaired_reflection": "On three complete oldplanes ordered(p0,q0,p1,q1,p2,q2), take v=(1,1,1,0,1,0), A=I+vv^T. Its support has three p chunks and one q. v^Tv=0, so A^2=A^T A=I. Apply it bitwise at all f positions. Writing d(x)=sum pbits-sum qbits, if v.x is odd then d(x)-d(Ax)=2 d_v(x)-2=0 mod4; otherwise zero. Thus R_A=D^-1 P_A D=P_A literally, with no extra Gaussian phase.", + "limits": [ + "A complete caller must retain the changed noncommuting kernelsN0R and their independent-input sourcecodes, all public couplings and the literal inverse.", + "The old scalar quadratic caller cannot be reused by pretendingK^2=-I.", + "No full exponent, stock/owner, all-size, precision or tape claim is made." + ], + "literal_gaussian_chart": "Ononebit Hp=e^(-i pi/4) S^-1 H S and Hq=e^(+i pi/4) S H S^-1, S=diag(1,i). Their scalar factors cancel within each actual pairN=i Hp Hq, giving the exact i^j formula above. This is a conjugation identity in Gaussian operators; no irrational phase is introduced by the implementedR, which usesonly D/P_A/D^-1 with Gaussian-unit entries.", + "marked_character_checks": { + "paired_negative_control": { + "all_f_lift": "The map is bitwise. With one residual mark r=(p0,q1^f), its owner inside the balanced support makes v.w=1 at every position and R fixes the character. An owner outside makes R complement only unmarked virtual bits. The marked owner bit is unchanged.", + "marked_C_commutes": true, + "one_mark_characters_checked": 24 + }, + "unpaired_escape": { + "actual_character_matrix_coefficient": [ + "1", + "0" + ], + "all_f_lift": "Put ones on all f q0 positions and zeros elsewhere. Bare bitwise ADDRESS sends this X character to ones on all p0,p1,p2 positions, changing exactly one residual mark into three for every f>=1. No diagonal pair gauge can remove this nonzero leakage.", + "input_X_character": 2, + "input_residual_marks": [ + 1, + 0, + 0 + ], + "output_X_character": 21, + "output_residual_marks": [ + 1, + 1, + 1 + ] + } + }, + "native_model_sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3", + "native_zero_lowering": "The useful unpaired R is the explicit bitwise binary ADDRESS map A=I+vv^T itself. Its inverse is the same literal scan. Both new scans use only completed old chunks. The fixed binary controller and all address/source work remain paid.", + "no_new_kappa": true, + "paired_actual_checks": [ + { + "f": 1, + "kernel_fourth_power": "I", + "kernel_power_native_arities": [ + 2, + 2, + 2, + 0 + ], + "native_R": 0, + "new_fresh_plane": 2, + "source_frame_commutes_actual_phase": true, + "source_old_native_planes": [ + 0, + 1 + ] + }, + { + "f": 2, + "kernel_fourth_power": "I", + "kernel_power_native_arities": [ + 4, + 4, + 4, + 0 + ], + "native_R": 0, + "new_fresh_plane": 2, + "source_frame_commutes_actual_phase": true, + "source_old_native_planes": [ + 0, + 1 + ] + }, + { + "f": 3, + "kernel_fourth_power": "I", + "kernel_power_native_arities": [ + 6, + 6, + 6, + 0 + ], + "native_R": 0, + "new_fresh_plane": 2, + "source_frame_commutes_actual_phase": true, + "source_old_native_planes": [ + 0, + 1 + ] + } + ], + "paired_one_bit_monomial_recipe": { + "linear_Z4": [ + 2, + 2, + 2, + 2, + 0, + 0 + ], + "matrix_rows": [ + 14, + 13, + 11, + 7, + 16, + 32 + ], + "offset": 0, + "phase": 0, + "quadratic_rows": [ + 0, + 0, + 0, + 0, + 0, + 0 + ] + }, + "paired_reflection_negative_control": "On two complete oldplanes v=1111 gives a legal typed R, but it COMMUTES with the marked-residual C. It is not an escape from that grammar floor. Its kernel K=N0R has exact K^4=I and nativearities2f,2f,2f,0 for its first four powers.", + "per_pair_invoice": { + "delivery_ADD_scans": 1, + "existing_source_ADDRESS_scans": 1, + "native_H2": 2, + "native_rank_mass": 4, + "new_R_ADDRESS_scans": 2, + "new_R_diagonal_phase_scans": 0, + "ordinary_helpers": 0, + "private_fields": 0 + }, + "producer_sha256": "c6373762bd15763625cc9237bb280a5e26ab8e53d6bfb034474f068b1525e6fa", + "scientific_pin": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "source_cut_binding": "At stagej with oldF=productfresh1..j-1, source N0oldF is full G_old. Insert R before the source delivery and R^-1 immediately after. Then sourcePj and targetNj give boundary Fnew[[Pj,0],[N0R,I]]. The sourceoriginal column, targetoriginal column, arbitrary source crosscolumn and literal inverse all retain their phases. This doesnot assert(N0R)^2=-I.", + "status": "PASS_ALL_F_ORTHOGONAL_TYPED_SOURCE_NORMALIZER", + "unpaired_actual_checks": [ + { + "actual_typed_R_equals_bare_ADDRESS": true, + "f": 1, + "kernel_native_arity": 2, + "native_R": 0, + "new_fresh_plane": 3, + "old_native_planes": [ + 0, + 1, + 2 + ], + "source_and_cross_columns_actual_phase": true + }, + { + "actual_typed_R_equals_bare_ADDRESS": true, + "f": 2, + "kernel_native_arity": 4, + "native_R": 0, + "new_fresh_plane": 3, + "old_native_planes": [ + 0, + 1, + 2 + ], + "source_and_cross_columns_actual_phase": true + } + ] +} diff --git a/research/one-query-endpoint-scan/source/native-frames/conjugated_factory.py b/research/one-query-endpoint-scan/source/native-frames/conjugated_factory.py new file mode 100644 index 0000000000..16db14187d --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/conjugated_factory.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +"""A one-child lowering for the genuinely two-sided R P2 R factory. +Apache-2.0; substantial OpenAI Codex assistance. No free source substitution. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * +from orthogonal_source_normalizer import reflection +from conjugated_reflection import tensor_monomial + +HERE = Path(__file__).resolve().parent + + +def run(): + z1 = Model(1, 3) + R1, _ = reflection(z1, 3, (0, 1, 2, 4)) + M1 = mul(R1, z1.P[1], R1) + B1 = mul(z1.N, M1, z1.N.adjoint()) + recipe, compiled = ce.lower_child(B1) + need(recipe['rank'] == 2, 'two-sided factory conjugate native2') + same(B1, compiled, 'literal one-bit factory lowering phase') + checks = [] + for f in (1, 2, 3): + z = Model(f, 3) + R, _ = reflection(z, 3, (0, 1, 2, 4)) + M = mul(R, z.P[1], R) + B = mul(z.N, M, z.N.adjoint()) + literal = mul(tensor_monomial(recipe['left'], f), + ce.fourier(z.n, range(2 * f)), tensor_monomial(recipe['right'], f)) + same(B, literal, 'two-sided factory all-f tensor recipe phase') + same(mul(B, B), z.I, 'two-sided factory literal involution') + ranks = [b.native_rank(mul(z.N, X, z.N.adjoint())) + for X in (z.P[1], mul(R, z.P[1]), mul(z.P[1], R), M)] + need(ranks == [4 * f, 4 * f, 4 * f, 2 * f], 'both R sides are required for this saving') + checks.append({'f': f, 'ranks_P2_RP2_P2R_RP2R': ranks, + 'actual_native_recipe_phase': True, 'inverse': 'same operator'}) + return {'status': 'PASS_ALL_F_TWO_SIDED_REFLECTION_FACTORY_SINGLE_CHILD', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'source_pins': [{'path': str(HERE/name), 'sha256': hashlib.sha256((HERE/name).read_bytes()).hexdigest()} + for name in ('native_model.py', 'orthogonal_source_normalizer.py', 'conjugated_reflection.py')], + 'exact_operator': 'B=N0 R P2 R N0^-1, P2=SWAP(plane0,plane2), R=ADDRESS(I+vv^T), v=(p0,q0,p1,p2).', + 'all_f_proof': 'P2_f and R_f are bitwise tensors. Global N_f phases cancel in conjugation, so B_f=B_1^tensor f. The explicit actual one-bit equality B_1=L C_2 R_adapter tensor-lifts with fixed bitwise ADDRESS/quadratic-phase controllers to one selected native2f query. B_1 has B-rank2, so B_f has exact B-rank2f, including all f-dependent adapter phase powers.', + 'one_bit_selected_native_recipe': recipe, + 'complete_unary_invoice': {'native_H2': 1, 'native_rank_mass': 2, + 'monomial_adapters': 2, 'ADDRESS_scans_at_most': 2, + 'Gaussian_quadratic_phase_scans_at_most': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'actual_checks': checks, + 'caller_obligation': 'This bill applies only to the literal B shown. An outgoing source P2 is not replaced for free. R uses the stage2-future plane2, so supplying both R sides at a legal caller cut with all source/target columns and fresh coverage is a separate obligation. A global chart change also transports N and cannot be used to claim this saving while holding N fixed.', + 'COPY_precision_tape_obligations': 'Native lowering is a Fourier/supplier query with arbitrary input. Any source COPY to a fanout, all bank reads, the two monomial ADDRESS/phase adapters, their reversible scans, precision/rounding propagation, source-bound block norms, and physical tape return remain paid caller obligations. No endpoint, all-size recursion, stock or exponent follows from this unary identity.', + 'evidence_domain': 'Written exact all-f tensor proof, actual Gaussian recipe and phase checks f1/f2/f3, and one-sided negative controls. No finite-f extrapolation and no formal-kernel claim.', + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'CONJUGATED-FACTORY.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'saved conjugated factory differs') + print(out['status']) + print(out['complete_unary_invoice']) diff --git a/research/one-query-endpoint-scan/source/native-frames/conjugated_reflection.py b/research/one-query-endpoint-scan/source/native-frames/conjugated_reflection.py new file mode 100644 index 0000000000..341df23adc --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/conjugated_reflection.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +"""One native child for the common conjugate of an unpaired ADDRESS reflection. +Apache-2.0; substantial OpenAI Codex assistance. This is a local resource. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * +from orthogonal_source_normalizer import reflection +from lifted_algebra import Algebra + +HERE = Path(__file__).resolve().parent + + +def tensor_monomial(recipe, f): + """Lift every one-bit wire and phase bitwise, retaining its actual phase.""" + chunks = len(recipe['matrix_rows']) + n = chunks * f + def bitlift(mask, k): + return sum(1 << (chunk * f + k) for chunk in range(chunks) if (mask >> chunk) & 1) + rows = [bitlift(recipe['matrix_rows'][chunk], k) for chunk in range(chunks) for k in range(f)] + quadratic = [bitlift(recipe['quadratic_rows'][chunk], k) for chunk in range(chunks) for k in range(f)] + alpha = [recipe['linear_Z4'][chunk] for chunk in range(chunks) for k in range(f)] + offset = sum(bitlift(recipe['offset'], k) for k in range(f)) + return mul(phase(n, f * recipe['phase']), ce.xgate(n, offset), + ce.perm(n, rows), ce.diag(n, quadratic, alpha)) + + +def run(): + z1 = Model(1, 3) + R1, _ = reflection(z1, 3, (0, 1, 2, 4)) + base_native = [z1.N, z1.T[0], z1.T[1]] + onebit_conjugates = [mul(Ni, R1, Ni.adjoint()) for Ni in base_native] + recipes = [] + for A in onebit_conjugates: + rec, compiled = ce.lower_child(A) + need(rec['rank'] == 2, 'one-bit conjugate has native rank2') + same(compiled, A, 'actual selected-native one-bit lowering') + recipes.append(rec) + A1, recipe = onebit_conjugates[0], recipes[0] + checks = [] + for f in (1, 2, 3): + z = Model(f, 3) + R, _ = reflection(z, 3, (0, 1, 2, 4)) + for plane, (Ni, rec) in enumerate(zip([z.N, z.T[0], z.T[1]], recipes)): + A = mul(Ni, R, Ni.adjoint()) + left = tensor_monomial(rec['left'], f) + right = tensor_monomial(rec['right'], f) + literal = mul(left, ce.fourier(z.n, range(2 * f)), right) + same(literal, A, 'tensor-lifted native child actual phase') + same(mul(A, A), z.I, 'conjugated reflection literal involution') + need(b.native_rank(A) == 2 * f, 'conjugated reflection rank2f') + need(b.native_rank(left) == b.native_rank(right) == 0, 'literal adapters monomial') + checks.append({'f': f, 'conjugating_old_plane': plane, + 'native_arity': 2 * f, 'inverse': 'same A', + 'tensor_recipe_actual_Gaussian_phase': True}) + + # Independently retain both bank columns over the exact all-f tensor algebra. + a = Algebra(3) + R, A = a.lift(R1), a.lift(A1) + def shear(sign): + out = a.mat_identity(2) + out[0][1] = a.scale(a.one, sign) + return out + E, Ei = shear(1), shear(-1) + BR = a.mat_product(a.mat_product(E, a.diagonal(2, 1, R)), Ei) + conjugated = a.mat_product(a.mat_product(a.diagonal(2, 0, a.N), a.diagonal(2, 1, a.N)), BR) + conjugated = a.mat_product(conjugated, a.mat_product(a.diagonal(2, 0, a.adjoint(a.N)), a.diagonal(2, 1, a.adjoint(a.N)))) + expected = a.mat_product(a.mat_product(E, a.diagonal(2, 1, A)), Ei) + need(conjugated == expected, 'two independent bank-column conjugation identity') + need(a.mat_product(expected, expected) == a.mat_identity(2), 'literal bank word inverse') + return {'status': 'PASS_ALL_F_SINGLE_CHILD_CONJUGATED_UNPAIRED_REFLECTION', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'reflection_source_sha256': hashlib.sha256((HERE/'orthogonal_source_normalizer.py').read_bytes()).hexdigest(), + 'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(), + 'actual_operator': 'R=P_(I+vv^T), v=(1,1,1,0,1,0) on completed(p0,q0,p1,q1,p2,q2); A=N0 R N0^-1.', + 'all_f_tensor_identity': 'R_f is the bitwise tensor product of R_1. N_f=i^(1-f) N_1^tensor f after regrouping address coordinates. Its global unit cancels in conjugation, so A_f=A_1^tensor f literally, including phase. Tensoring the explicit one-bit monomial/native/monomial equality therefore gives A_f=L_f C_(2f) R_f_adapter. All three factors have fixed bitwise controllers; no f1 tableau-only inference is used.', + 'native_rank_proof': 'The binary B block of A_1 has rank2. Direct sums under bitwise tensor regrouping have rank2f, so A_f and its inverse have exact native arity2f for every f>=1. A_f^2=I by conjugation of R_f^2=I.', + 'one_bit_selected_native_recipe': recipe, + 'one_bit_selected_native_recipes_by_old_plane': recipes, + 'actual_tensor_recipe_checks': checks, + 'old_plane_extension': 'The same exact single-child admission holds for A_i=N_i R N_i^-1 on each i=0,1,2, with the three explicit recipes retained. Since N_i=i H_i and H_i=Hp_i Hq_i is involutive, this is also H_i R H_i without any external i. The tensor proof and all adapter phase powers apply separately to each saved recipe.', + 'single_unary_invoice': {'native_H2': 1, 'native_rank_mass': 2, + 'monomial_adapters': 2, 'ADDRESS_scans_at_most': 2, + 'Gaussian_quadratic_phase_scans_at_most': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'two_bank_identity': 'For E12=I+e1e2^T and B_R=E12 diag(I,R) E12^-1, Ad_(diag(N,N))(B_R)=E12 diag(I,A) E12^-1. Both independent inputs are retained. Its literal inverse reverses the shears and applies A^-1=A; the entire displayed conjugated word is itself involutive.', + 'two_bank_invoice': {'native_H2': 1, 'native_rank_mass': 2, + 'scalar_ADD_scans': 2, 'monomial_adapters': 2, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'evidence_domain': 'Written all-f exact tensor proof and native B-rank proof; independent actual Gaussian compiled checks at f1/f2/f3; all-f two-bank polynomial coefficients checked in the phase-sensitive tensor algebra.', + 'limits': ['This is a changed legal local bridge, not a completed caller or shared-debt cancellation.', + 'The source-kernel N0R is not assumed quadratic, and no old scalar caller is imported by that assumption.', + 'All bank ADD, ADDRESS and phase scans are paid; no source access, owner, precision, all-size or tape gate is discharged.'], + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'CONJUGATED-REFLECTION.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'saved conjugated reflection differs') + print(out['status']) + print(out['single_unary_invoice']) diff --git a/research/one-query-endpoint-scan/source/native-frames/dual_reflections.py b/research/one-query-endpoint-scan/source/native-frames/dual_reflections.py new file mode 100644 index 0000000000..cf51b610d0 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/dual_reflections.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +"""Exact dual unpaired ADDRESS reflections and all18 one-child conjugates. +Apache-2.0; substantial OpenAI Codex assistance. Local native admission only. +""" +from pathlib import Path +import argparse +import hashlib +import json +from native_model import * +from orthogonal_source_normalizer import reflection +from conjugated_reflection import tensor_monomial +from lifted_algebra import Algebra + +HERE=Path(__file__).resolve().parent + + +def role_duality(model): + rows=[1<0 and c>=0:q=j;break + need(q is not None,'canonical Gaussian amplitude phase') + if key not in self.rep:self.rep[key]=op.then(phase(op.n,-q)) + return key,q + def multiply_keys(self,a,c): + if(a,c)not in self.products:self.products[(a,c)]=self.canonical(mul(self.rep[a],self.rep[c])) + return self.products[(a,c)] + def adjoint_key(self,a): + if a not in self.inverses:self.inverses[a]=self.canonical(self.rep[a].adjoint()) + return self.inverses[a] + def lift(self,dist,bulk=None,exponent=0): + if bulk is None:bulk=dist + kd,qd=self.canonical(dist);kb,qb=self.canonical(bulk) + need(b.binary_tableau(dist)==b.binary_tableau(bulk),'distinguished difference must be Pauli only') + return{(kd,kb):phasevec(lambda r:exponent*(1-r)+qd+qb*(r-1))} + def add(self,a,c): + out=dict(a) + for k,v in c.items(): + w=cadd(out.get(k,(ZERO,)*4),v) + if czero(w):out.pop(k,None) + else:out[k]=w + return out + def scale(self,a,c): + if not isinstance(c,G):c=G(F(c)) + return{k:tuple(c*x for x in v)for k,v in a.items()if c} + def product(self,a,c): + out={} + for(ad,ab),av in a.items(): + for(cd,cb),cv in c.items(): + kd,qd=self.multiply_keys(ad,cd);kb,qb=self.multiply_keys(ab,cb);phase=phasevec(lambda r:qd+qb*(r-1));value=cmul(cmul(av,cv),phase);key=(kd,kb);value=cadd(out.get(key,(ZERO,)*4),value) + if czero(value):out.pop(key,None) + else:out[key]=value + return out + def adjoint(self,a): + out={} + for(ad,ab),av in a.items(): + kd,qd=self.adjoint_key(ad);kb,qb=self.adjoint_key(ab);value=cmul(cconj(av),phasevec(lambda r:qd+qb*(r-1)));out=self.add(out,{(kd,kb):value}) + return out + def mat_identity(self,n):return[[dict(self.one)if i==j else{}for j in range(n)]for i in range(n)] + def mat_product(self,a,c): + n=len(a);out=[[{}for j in range(n)]for i in range(n)] + for i in range(n): + for k in range(n): + if not a[i][k]:continue + for j in range(n): + if c[k][j]:out[i][j]=self.add(out[i][j],self.product(a[i][k],c[k][j])) + return out + def router(self,n,a,c,selector=0,sign=1): + out=self.mat_identity(n);Q=self.scale(self.Q[selector],sign);ep=self.scale(self.add(self.one,Q),F(1,2));em=self.scale(self.add(self.one,self.scale(Q,-1)),F(1,2));out[a][a]=out[c][c]=ep;out[a][c]=out[c][a]=em;return out + def diagonal(self,n,bank,op):out=self.mat_identity(n);out[bank][bank]=op;return out + def continuation(self,choice): + if choice=='U':return self.U + if choice=='V':return self.V + # alpha_f=(-i)^(f+1), selected completed fresh1 p-bit. Conditional + # continuation is directly admitted by the R diag(U,I) R word. + need(choice in('C+','C-'),'known role') + Q=self.Q[1];ep=self.scale(self.add(self.one,Q),F(1,2));em=self.scale(self.add(self.one,self.scale(Q,-1)),F(1,2));alpha=phasevec(lambda r:-r-1);av={k:cmul(v,alpha)for k,v in self.V.items()} + return self.add(self.product(ep if choice=='C+'else em,self.U),self.product(em if choice=='C+'else ep,av)) + def box(self,n,stage,kind,target,source,role='U',c=1,target_P=False): + out=self.mat_identity(n);W=self.continuation(role);P=self.P[stage] + if kind=='F':out[source][source]=self.product(W,P);out[target][source]=self.scale(self.N,c) + elif kind=='G': + Wi=self.adjoint(W);out[source][source]=Wi;out[target][target]=P;out[target][source]=self.scale(self.product(self.product(P,self.N),Wi),c) + else:raise ValueError(kind) + if target_P: + need(kind=='F','only forward postdelivery/pre-T target P admitted') + out=self.mat_product(self.diagonal(n,target,P),out) + return out + def allf_target_residual(self,a): + # Right-normalize the desired full native common N. A positive result + # has entries in the fixed distinguished Pauli algebra, bulk identity. + Ni=self.adjoint(self.N);res=[] + for row in a: + rr=[] + for entry in row: + v=self.product(entry,Ni) + if any(kb!=self.idkey for kd,kb in v):return None + if any(b.binary_tableau(self.rep[kd])!=b.binary_tableau(ce.ident(self.m))for kd,kb in v):return None + rr.append(v) + res.append(rr) + return res + def fingerprint(self,a): + return tuple(tuple(tuple(sorted((str(k),tuple((v.a,v.b)for v in vec))for k,vec in entry.items()))for entry in row)for row in a) diff --git a/research/one-query-endpoint-scan/source/native-frames/native_model.py b/research/one-query-endpoint-scan/source/native-frames/native_model.py new file mode 100644 index 0000000000..0ab770f491 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/native_model.py @@ -0,0 +1,67 @@ +"""Pinned Gaussian Clifford model for common2/fresh2 native bridges. +Apache-2.0; substantial OpenAI Codex assistance. Frozen imports are read only. +""" +from pathlib import Path +import hashlib,importlib.util,sys +sys.dont_write_bytecode=True +BASE=Path(__file__).resolve().parents[1] +PIN='20ecf2891d80b5acf18d980b2164fb44ea7faa90' +CE_PATH=BASE/'vendor/clifford_exact.py' +CE_SHA='2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962' +BOUND_PATH=BASE/'vendor/full_stabilizer_bound.py' +BOUND_SHA='f073a00ad4831616e873eb110fd33ad7226010a7c2f6cfa6a6b63167bf58ef75' +def need(ok,why): + if not ok:raise ValueError(why) +def load(name,path,sha): + need(hashlib.sha256(path.read_bytes()).hexdigest()==sha,'source pin '+str(path)) + spec=importlib.util.spec_from_file_location(name,path);mod=importlib.util.module_from_spec(spec);sys.modules[name]=mod;spec.loader.exec_module(mod);return mod +ce=load('native_frames_pinned_clifford',CE_PATH,CE_SHA) +b=load('native_frames_frozen_independent',BOUND_PATH,BOUND_SHA) +def mul(*ops):return b.standard_product(ce,*ops) +def same(a,c,why,phase=True): + need(a.tab==c.tab,why+' signed tableau') + if phase:need(b.sparse_column(a)==b.sparse_column(c),why+' actual Gaussian phase') +def phase(n,p):return ce.Op(n,ce.identity(n),[('phase',p%4)]) +def symplectic_defect_rank(op): + return b.binary_rank(x^y for x,y in zip(b.binary_tableau(op),b.binary_tableau(ce.ident(op.n)))) +def pauli(n,x=0,z=0,p=0): + out=ce.diag(n,[0]*n,[2*((z>>j)&1)for j in range(n)]) + return mul(phase(n,p),ce.xgate(n,x),out) +def conjugated_pauli(op,x=0,z=0,p=0): + triple=ce.apply(op.tab,(x,z,p));return pauli(op.n,*triple),triple +class Model: + def __init__(self,f=1,stages=4): + need(f>=1 and stages>=1,'positive chunk/stages');self.f=f;self.stages=stages;self.n=(2+2*stages)*f;self.I=ce.ident(self.n) + self.N=self.Npair(0,1);self.U=self.Hp(0);self.V=mul(self.N,self.U.adjoint()) + self.P=[self.swap_pair(s+1)for s in range(stages)];self.T=[self.Npair(2+2*s,3+2*s)for s in range(stages)] + self.Q=ce.xgate(self.n,1) + def Hp(self,chunk): + out=self.I + for j in range(self.f): + bit=chunk*self.f+j;alpha=[0]*self.n;alpha[bit]=2 + out=mul(ce.diag(self.n,[0]*self.n,alpha),ce.cgate(self.n,1<=4,'pqqp uses4 stages');gs=[self.I,self.I];controls=[];F=self.I + for s,(kind,W) in enumerate(zip('FGFG',[self.U,self.V,self.V,self.U])): + required=self.phi(gs[1])if kind=='F'else mul(W,self.N.adjoint(),gs[1],self.N,W.adjoint()) + L=mul(required,gs[0].adjoint());controls.append(L);gs[0]=required + if kind=='F':gs=[gs[0],mul(W,self.P[s],gs[1],W.adjoint())] + else:gs=[mul(W.adjoint(),gs[0],W),mul(self.P[s],gs[1])] + F=mul(self.T[s],F) + return gs,controls diff --git a/research/one-query-endpoint-scan/source/native-frames/orthogonal_source_normalizer.py b/research/one-query-endpoint-scan/source/native-frames/orthogonal_source_normalizer.py new file mode 100644 index 0000000000..9ffbd4da72 --- /dev/null +++ b/research/one-query-endpoint-scan/source/native-frames/orthogonal_source_normalizer.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python3 +"""Gaussian-typed binary orthogonal normalizers at a full source cut. + +This is a genuine bit-linear ADDRESS extension beyond plane permutations +and X translations. It is not itself a completed caller construction. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from fractions import Fraction +import argparse +import hashlib +import json +from native_model import * + +HERE = Path(__file__).resolve().parent + + +def typed_D(model, oldplanes): + alpha, quadratic = [0] * model.n, [0] * model.n + for chunk in range(2 * oldplanes): + for bit in range(model.f): + k = chunk * model.f + bit + alpha[k] = 1 if chunk % 2 == 0 else 3 + quadratic[k] = 1 << k + return ce.diag(model.n, quadratic, alpha) + + +def reflection(model, oldplanes=2, support=(0, 1, 2, 3)): + need(len(support) % 2 == 0 and len(support) > 0, 'even nonempty reflection support') + need(max(support) < 2 * oldplanes, 'reflection uses only completed old chunks') + rows = [1 << j for j in range(model.n)] + for out in support: + for bit in range(model.f): + rows[out * model.f + bit] ^= sum(1 << (src * model.f + bit) + for src in support) + D = typed_D(model, oldplanes) + P = ce.perm(model.n, rows) + return mul(D.adjoint(), P, D), rows + + +def gaussian_add(a, c): + return a[0] + c[0], a[1] + c[1] + + +def unit(power): + return ((1, 0), (0, 1), (-1, 0), (0, -1))[power % 4] + + +def marked_character_checks(): + # Actual 64-point Fourier character sum, independent of Clifford tableaux. + def residual(w): + return tuple(((w >> (2 * k)) ^ (w >> (2 * k + 1))) & 1 for k in range(3)) + + def character_coefficient(w, wp, support): + v = sum(1 << k for k in support) + coefficient = (0, 0) + for x in range(64): + Ax = x ^ (v if (x & v).bit_count() % 2 else 0) + dx = sum((1 if k % 2 == 0 else -1) * ((x >> k) & 1) for k in range(6)) + dAx = sum((1 if k % 2 == 0 else -1) * ((Ax >> k) & 1) for k in range(6)) + sign = 2 * (((w & x).bit_count() + (wp & Ax).bit_count()) % 2) + coefficient = gaussian_add(coefficient, unit(dx - dAx + sign)) + return [Fraction(a, 64) for a in coefficient] + + # The initially proposed balanced reflection is NOT an escape. It maps + # w to w+(v.w+1)v and preserves both the unique mark and its virtual bit. + v = 15 + paired_checked = 0 + for w in range(64): + marks = residual(w) + if sum(marks) != 1: + continue + wp = w ^ (v if ((w & v).bit_count() + 1) % 2 else 0) + owner = marks.index(1) + need(character_coefficient(w, wp, (0, 1, 2, 3)) == [1, 0], 'paired exact character map') + need(residual(wp) == marks and ((w >> (2 * owner)) & 1) == ((wp >> (2 * owner)) & 1), 'paired reflection commutes marked C') + paired_checked += 1 + # Unpaired three-p/one-q reflection is bare ADDRESS, sending q0 to p0+p1+p2. + w, wp = 2, 21 + coefficient = character_coefficient(w, wp, (0, 1, 2, 4)) + need(coefficient == [1, 0], 'unpaired actual character coefficient') + need(residual(w) == (1, 0, 0) and residual(wp) == (1, 1, 1), 'genuine marked-subspace leakage') + return {'paired_negative_control': {'one_mark_characters_checked': paired_checked, + 'marked_C_commutes': True, + 'all_f_lift': 'The map is bitwise. With one residual mark r=(p0,q1^f), its owner inside the balanced support makes v.w=1 at every position and R fixes the character. An owner outside makes R complement only unmarked virtual bits. The marked owner bit is unchanged.'}, + 'unpaired_escape': {'input_X_character': w, 'input_residual_marks': residual(w), + 'output_X_character': wp, 'output_residual_marks': residual(wp), + 'actual_character_matrix_coefficient': [str(x) for x in coefficient], + 'all_f_lift': 'Put ones on all f q0 positions and zeros elsewhere. Bare bitwise ADDRESS sends this X character to ones on all p0,p1,p2 positions, changing exactly one residual mark into three for every f>=1. No diagonal pair gauge can remove this nonzero leakage.'}} + + +def run(): + checks = [] + onebit_recipe = None + for f in (1, 2, 3): + z = Model(f, 2) + R, rows = reflection(z) + oldG = mul(z.N, z.T[0]) + same(mul(R, R), z.I, 'actual orthogonal normalizer involution') + same(mul(R, oldG), mul(oldG, R), 'actual full-source normalizer phase') + need(b.native_rank(R) == 0, 'orthogonal typed reflection is monomial') + # Literal two-bank source insertion, with oldfresh=N1 and newfresh=N2. + actual_source = mul(z.P[1], R.adjoint(), R, z.N, z.T[0]) + actual_cross = mul(z.T[1], R, z.N, z.T[0]) + desired_source = mul(z.T[1], z.T[0], z.P[1]) + desired_cross = mul(z.T[1], z.T[0], z.N, R) + same(actual_source, desired_source, 'unchanged sourcecode and fresh coverage') + same(actual_cross, desired_cross, 'changed delivery N0R on arbitrary source column') + # The raw target coefficient is N2 N1 and is independent of source. + K = mul(z.N, R) + power = z.I + ranks = [] + for exponent in range(1, 5): + power = mul(K, power) + ranks.append(b.native_rank(power)) + same(power, z.I, 'exact quartic phase of this reflection kernel') + need(ranks == [2 * f, 2 * f, 2 * f, 0], 'kernel power is not an unproved full-native completion') + if f == 1: + compiled, onebit_recipe = ce.monomial(R) + same(R, compiled, 'actual literal Gaussian monomial recipe') + checks.append({'f': f, 'native_R': 0, 'source_old_native_planes': [0, 1], + 'new_fresh_plane': 2, 'source_frame_commutes_actual_phase': True, + 'kernel_power_native_arities': ranks, 'kernel_fourth_power': 'I'}) + unpaired_checks = [] + for f in (1, 2): + z = Model(f, 3) + R, rows = reflection(z, 3, (0, 1, 2, 4)) + bare = ce.perm(z.n, rows) + oldG = mul(z.N, z.T[0], z.T[1]) + same(R, bare, 'unpaired typed normalizer is literally bare ADDRESS') + same(mul(R, R), z.I, 'unpaired reflection literal involution') + same(mul(R, oldG), mul(oldG, R), 'unpaired full-source Gaussian phase') + need(b.native_rank(R) == 0, 'unpaired ADDRESS is nativezero') + actual_source = mul(z.P[2], R.adjoint(), R, z.N, z.T[0], z.T[1]) + actual_cross = mul(z.T[2], R, z.N, z.T[0], z.T[1]) + same(actual_source, mul(z.T[2], z.T[0], z.T[1], z.P[2]), 'unpaired unchanged source column') + same(actual_cross, mul(z.T[2], z.T[0], z.T[1], z.N, R), 'unpaired changed cross column phase') + need(b.native_rank(mul(z.N, R)) == 2 * f, 'changed cross native arity') + unpaired_checks.append({'f': f, 'old_native_planes': [0, 1, 2], 'new_fresh_plane': 3, + 'actual_typed_R_equals_bare_ADDRESS': True, 'native_R': 0, + 'source_and_cross_columns_actual_phase': True, + 'kernel_native_arity': 2 * f}) + characters = marked_character_checks() + return {'status': 'PASS_ALL_F_ORTHOGONAL_TYPED_SOURCE_NORMALIZER', + 'scientific_pin': PIN, + 'producer_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'native_model_sha256': hashlib.sha256((HERE/'native_model.py').read_bytes()).hexdigest(), + 'all_parameter_schema': 'For j old native planes (2j chunks), put D=diag phasei on everyoldp bit and-i on everyoldq bit. Exact G_old=product(N_i)=i^j D^-1 H_all D. If binaryA is orthogonal,A^T A=I, then its literal ADDRESS permutation P_A commutes ordinary WalshH_all. Hence R_A=D^-1 P_A D is monomial and commutesG_old, including all global phases, for every f>=1.', + 'paired_reflection_negative_control': 'On two complete oldplanes v=1111 gives a legal typed R, but it COMMUTES with the marked-residual C. It is not an escape from that grammar floor. Its kernel K=N0R has exact K^4=I and nativearities2f,2f,2f,0 for its first four powers.', + 'explicit_unpaired_reflection': 'On three complete oldplanes ordered(p0,q0,p1,q1,p2,q2), take v=(1,1,1,0,1,0), A=I+vv^T. Its support has three p chunks and one q. v^Tv=0, so A^2=A^T A=I. Apply it bitwise at all f positions. Writing d(x)=sum pbits-sum qbits, if v.x is odd then d(x)-d(Ax)=2 d_v(x)-2=0 mod4; otherwise zero. Thus R_A=D^-1 P_A D=P_A literally, with no extra Gaussian phase.', + 'literal_gaussian_chart': 'Ononebit Hp=e^(-i pi/4) S^-1 H S and Hq=e^(+i pi/4) S H S^-1, S=diag(1,i). Their scalar factors cancel within each actual pairN=i Hp Hq, giving the exact i^j formula above. This is a conjugation identity in Gaussian operators; no irrational phase is introduced by the implementedR, which usesonly D/P_A/D^-1 with Gaussian-unit entries.', + 'source_cut_binding': 'At stagej with oldF=productfresh1..j-1, source N0oldF is full G_old. Insert R before the source delivery and R^-1 immediately after. Then sourcePj and targetNj give boundary Fnew[[Pj,0],[N0R,I]]. The sourceoriginal column, targetoriginal column, arbitrary source crosscolumn and literal inverse all retain their phases. This doesnot assert(N0R)^2=-I.', + 'per_pair_invoice': {'native_H2': 2, 'native_rank_mass': 4, + 'delivery_ADD_scans': 1, + 'existing_source_ADDRESS_scans': 1, + 'new_R_ADDRESS_scans': 2, + 'new_R_diagonal_phase_scans': 0, + 'ordinary_helpers': 0, 'private_fields': 0}, + 'native_zero_lowering': 'The useful unpaired R is the explicit bitwise binary ADDRESS map A=I+vv^T itself. Its inverse is the same literal scan. Both new scans use only completed old chunks. The fixed binary controller and all address/source work remain paid.', + 'paired_one_bit_monomial_recipe': onebit_recipe, + 'paired_actual_checks': checks, + 'unpaired_actual_checks': unpaired_checks, + 'marked_character_checks': characters, + 'evidence_domain': 'Written all-j/all-f orthogonal conjugation proof and explicit all-f bare-phase/leakage proof; actual Gaussian phase/source-column checks for pairedj2 f1/f2/f3 and unpairedj3 f1/f2; independent64-point actual Fourier-character sums. The paired candidate is correctly rejected as a marked-C escape. No f1-only native admission is extrapolated.', + 'limits': ['A complete caller must retain the changed noncommuting kernelsN0R and their independent-input sourcecodes, all public couplings and the literal inverse.', + 'The old scalar quadratic caller cannot be reused by pretendingK^2=-I.', + 'No full exponent, stock/owner, all-size, precision or tape claim is made.'], + 'no_new_kappa': True} + + +if __name__ == '__main__': + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--write', action='store_true') + args = p.parse_args() + out = json.loads(json.dumps(run())) + path = HERE/'ORTHOGONAL-SOURCE-NORMALIZER.json' + if args.write: + path.write_text(json.dumps(out, indent=2, sort_keys=True)+'\n') + else: + need(json.loads(path.read_text()) == out, 'saved orthogonal normalizer differs') + print(out['status']) + print(out['marked_character_checks']['unpaired_escape']) diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/DUAL-REFLECTION-SCREEN.json b/research/one-query-endpoint-scan/source/q4-pauli-fusion/DUAL-REFLECTION-SCREEN.json new file mode 100644 index 0000000000..3c5d6cb36e --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/DUAL-REFLECTION-SCREEN.json @@ -0,0 +1,358 @@ +{ + "ADDRESS_definition": "Rj transvection vector allp+qj; Sj vector allq+pj. Both act bitwise at allf. Enlarged endpoints additionally admit independent S3 permutations ofp/q chunks.", + "X_character_orbits": [ + [ + 0 + ], + [ + 1, + 4, + 7, + 13, + 16, + 19, + 22, + 25, + 28, + 31, + 37, + 42, + 49, + 52, + 55, + 61 + ], + [ + 2, + 8, + 11, + 14, + 21, + 26, + 32, + 35, + 38, + 41, + 44, + 47, + 50, + 56, + 59, + 62 + ], + [ + 3, + 6, + 9, + 12, + 15, + 18, + 24, + 27, + 30, + 33, + 36, + 39, + 45, + 48, + 51, + 54, + 57, + 60 + ], + [ + 5, + 17, + 20, + 43, + 46, + 58 + ], + [ + 10, + 23, + 29, + 34, + 40, + 53 + ], + [ + 63 + ] + ], + "all_f_binding": "Ni,f=i*(-i*Ni,1)^tensorf. All ADDRESSs and admitted Ai/B queries tensor-lift their exact one-bit monomials. Gaussian proportional-ray phases are folded separately for all4 residues; no f1-only linear relation is used.", + "all_residue_word_hits": [], + "bank_pattern": [ + 0, + 1, + 0, + 1, + 0 + ], + "controls": [ + "Sixteen pruned actual prefixes checked against all26 unpruned last-query completions in all4 residues.", + "Exact target diag(E3,E3) accepted by row prune and full unitary endpoint test in all4 residues." + ], + "counts": { + "all_last_queries_pruned_prefixes": 456976, + "covered_five_query_words": 11881376, + "four_query_prefixes": 456976, + "pruned_controls": 16 + }, + "exact_free_ADDRESS_group_order": 576, + "exact_scope": "Five queries; fixed alternating banks and the displayed four W routes; query alphabet exactly the serialized26 signed choices; arbitrary outer GL2 over the displayed complete finite ADDRESS group. Additional internal scalar/Pauli/ADDRESS bridges and other bank/route patterns are untested.", + "hits_by_f_mod4": { + "0": [], + "1": [], + "2": [], + "3": [] + }, + "no_new_kappa": true, + "paid_native_tariff": "Each Ni, Aij=NiRjNi^-1 and B=N0R0P2R0N0^-1 is one independently admitted rank2f child with its literal monomial adapters. No dual conjugate query is assumed.", + "producer_sha256": "63c6d8a2d6ab986138cade152b8279de20865f95dd0a2c270024c4dfd9575ae4", + "prune_proof": "Final query acts only onbank0. The two bank1 entries are unchanged, so their nonaccepted tensor rays cannot be repaired. Distinct base rays have independent sufficiently high tensor powers in each residue class. The row test is a necessary all-f condition, not a heuristic.", + "query_alphabet": [ + { + "kind": "N", + "negative": false, + "operator": 1, + "plane": 0, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 1, + "plane": 0, + "scalar_phase": 3 + }, + { + "kind": "N", + "negative": false, + "operator": 2, + "plane": 1, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 2, + "plane": 1, + "scalar_phase": 3 + }, + { + "kind": "N", + "negative": false, + "operator": 3, + "plane": 2, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 3, + "plane": 2, + "scalar_phase": 3 + }, + { + "kind": "A", + "negative": false, + "operator": 9, + "plane": 0, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 9, + "plane": 0, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 11, + "plane": 1, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 11, + "plane": 1, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 13, + "plane": 2, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 13, + "plane": 2, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 299, + "plane": 0, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 299, + "plane": 0, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 301, + "plane": 1, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 301, + "plane": 1, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 303, + "plane": 2, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 303, + "plane": 2, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 305, + "plane": 0, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 305, + "plane": 0, + "reflection": 2, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 307, + "plane": 1, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 307, + "plane": 1, + "reflection": 2, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 309, + "plane": 2, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 309, + "plane": 2, + "reflection": 2, + "scalar_phase": 2 + }, + { + "ADDRESS_plane_swap": 2, + "kind": "B_full_conjugate", + "negative": false, + "operator": 311, + "plane": 0, + "reflection": 0, + "scalar_phase": 0 + }, + { + "ADDRESS_plane_swap": 2, + "kind": "B_full_conjugate", + "negative": true, + "operator": 311, + "plane": 0, + "reflection": 0, + "scalar_phase": 2 + } + ], + "route_pattern": [ + "R0", + "S0", + "R1", + "S1" + ], + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/unpaired_reflection_screen.py", + "sha256": "cc385b510da37946acc0f9882f74d30f3431e8c9ef9e99dd5699aeaa81ec531e" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/varied_reflection_screen.py", + "sha256": "59fe8f29770c7ec7e75b5ab29716f1dd7a35404e74919e5370bc04cc2df41c86" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-REFLECTION.json", + "sha256": "15980d81733f121d23f7e95f1fb50aa3dccfdc67fb79794b4a93e34f8874293f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_factory.py", + "sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-FACTORY.json", + "sha256": "dc3a105b7ce7d226aeb8996aea6454ee66d65d9b9529af159d417f00bec02d34" + } + ], + "status": "PASS_EXACT_PRUNED_DUAL_ROUTE_SCREEN", + "target": "diag(E3,E3), everyf>=1, arbitrary independent inputs" +} diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/EXTENSION-HANDOFF.md b/research/one-query-endpoint-scan/source/q4-pauli-fusion/EXTENSION-HANDOFF.md new file mode 100644 index 0000000000..d682945fc8 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/EXTENSION-HANDOFF.md @@ -0,0 +1,228 @@ +# Complementary word-composition continuation + +Scientific pin: `20ecf2891d80b5acf18d980b2164fb44ea7faa90`. +Original round: 2026-10-19 07:16:51Z; constructive cutoff10:56:51Z; +deadline11:16:51Z. This continuation does not reset the round or its goal. +Only this `q4-pauli-fusion/` directory was edited. The18 original owned +files in `MANIFEST.json` remain hash-identical. No publication occurred. + +The continuation found an exact scalable source-handoff prefix and two +useful scoped obstructions. It did **not** find a completed positive +stock-saving caller. All finite checks use explicit exceptions that +survive `python3 -O`; no formal-kernel claim is made. + +## Actual source handoff and independently replayed scalable family + +`source_handoff_prefix.py` / `SOURCE-HANDOFF-PREFIX.json` give the complete +physical five-stage six-bank prefix, all independent columns, actual +native phases, both inverse matrix orders and a literal serialized +reverse. Normal and `-O` modes pass. It costs34 rank2f children, mass68f +against stock72f **before** the dirty-pivot tail. + +At the fourth source cut in retarded frameF3, the actual banks are + +``` +(a, u+C, Nx-v, Nu+a+B, B, -v-N(a+B)). +``` + +All six inputs `(a,x,B,C,u,v)` are independent. The two changed handoffs +are reconstructible directly from the producer. In particular they +swap a held source into the source bank **after** its already-paid +common native exposure and **before** its ADDRESS stage. They retain +both independent pivot directions. The pre-P5 fanout is paid while its +source literally holds `-v-Na`; a later standaloneN(a) finishes the +remaining public direction. + +`handoff_family_independent.py` / `INDEPENDENT-HANDOFF-FAMILY.json` +independently reconstruct the mixed worker's all-q word using an +opposite right-normal plane algebra. Canonical event traces agree for +q2..5. Public columns, both inverse products and literal reversal pass +for q in `{2,3,4,5,6,8,12,16}`. Omitting the q3+ raw-a repair is rejected. +The complete declared prefix histogram is + +``` +n=2q+2, m=(4q+4)f, +H2=n(2q+1)+q+2, D_prefix=2qf. +``` + +The independent progress scheduler moves a request through a unary +event only after exact commutation, transports it through actual bank +swaps, and flushes it at every incompatible event/ADD participant. +Every resulting wide native batch and its phase adapter is recorded. +This proves legal complete-column batching for the finite q range; +it does not substitute a bulk invoice for an actual word. + +The literal direct inverse-factory tail from the mixed/native workers +has mass `(2q+8)f`, giving complete unretimedD=-8f. The two external +factory supports are disjoint and have total sizeq, so direct factory +inversion consumes the prefix's2qf gain. Parent independently found a +complete n6 chart retiming at exactly stock and an exact lower bound +for that fixed skeleton. None of these facts is a lower bound for +arbitrarily changed joint terminal bridges. + +## Global stock floor inside the whole-plane/X grammar + +`marked_residual_gate.py` / `MARKED-RESIDUAL-GLOBAL-FLOOR.json` and +`MARKED-RESIDUAL-GLOBAL-FLOOR.md` give a written all-f/all-L commutator +proof, exact finite witnesses and explicit scope. Normal/-O pass. +Parent independently verified it using actual Gaussian physical +matrices and a separate embedding. + +For native products of whole ordered2f planes, arbitrary whole-plane +permutations, X translations and arbitrary bank GL bridges commuting +the witness, native plane count is at leastnL. Thus mass is at leastnm, +even with arbitrary restored identity helpers. The fixed-cut joint +tail additionally needs at leastq+3 native planes in this grammar. + +This scope excludes general PauliZ, arbitrary bitlinear ADDRESSs and +native adapters not proved to commute the witness. The actual unpaired +reflection below escapes it. The theorem therefore does not close +the enlarged native alphabet. + +## Genuine unpaired-reflection escape and bounded five-query screens + +Use bitwise bare ADDRESS transvections + +``` +Rj: v=all three p chunks + qj, +Sj: v=all three q chunks + pj, +A=I+v*v^T overF2. +``` + +These are actual monomial involutions commuting the full three-plane +nativeE3. They act on the entire bulk at everyf. They are distinct from +paired whole-plane reflections, which preserve the old marked block. +R0 sends a one-mark X-character residual to a three-mark residual. + +The native worker separately supplied exact single-rank2f recipes for +every `Ni Rj Ni^-1`, every dual `Ni Sj Ni^-1`, and the full conjugate +`N0 R0 P2 R0 N0^-1`. Each tariff includes two actual monomial adapters. +The search charges these fused primitives once using that independent +native admission; it does not infer tariff from a twoN group word. + +Three complete fixed grammars targeting `diag(E3,E3)` were negative: + +| Screen | Declared five-query candidates | Internal routes | Outer algebra | +| --- | ---: | --- | --- | +| `UNPAIRED-REFLECTION-SCREEN.json` | 24^5 =7,962,624 | repeatedW(R0) | fullGL2(Q(i)[R0]) | +| `VARIED-REFLECTION-SCREEN.json` | 26^5 =11,881,376 | W(R0),W(R1),W(R2),W(R0) | full144-element ADDRESS-group algebra | +| `DUAL-REFLECTION-SCREEN.json` | 26^5 =11,881,376 | W(R0),W(S0),W(R1),W(S1) | full576-element ADDRESS-group algebra | + +The first screen allows either bank at each query. The latter two fix +the alternating bank pattern0,1,0,1,0. The26 signed choices are3Ni, +9 primal conjugates, and the full conjugate above; dual **queries** +were not added to this alphabet. Both endpoints are arbitrary GL2 in +the stated algebra, separately for everyf residue. Additional internal +scalar phases, PauliZ routes, other ADDRESSs or route/bank patterns +remain outside these finite searches. + +The unpruned repeated screen passes normal/-O. The unpruned varied +screen passes normal mode. A separate exact pruned replay passes +normal/-O and agrees with the unpruned varied result. It rejects all +456,976 four-query prefixes because the final query cannot touch a +bank row that already lies outside the accepted endpoint algebra. +The dual screen independently has the same complete prefix count and +zero completions, normal/-O. Sixteen pruned-prefix controls each check +all26 unpruned final choices in all4 residues. An exact target control +is accepted. + +The tensor-base proof keeps exact Gaussian monomial rays, using +`Ni,f=i*(-i*Ni,1)^tensorf`. It never promotes f1 linear relations to +all-size identities. Distinct nonproportional tensor rays are +independent at every sufficiently high degree, so a ray-support failure +is a rigorous all-f failure within the stated finite grammar, even +when scalar endpoint coefficients depend onf. + +## Changed two-carrier one-query obstruction + +`ONE-QUERY-ENDPOINT-OBSTRUCTION.md/.json` and +`one_query_endpoint_obstruction.py` establish the stronger local gate +for `C=[[Q-I,N],[Q,0]]`. The root supplied both arguments; this lane +verified the actual Gaussian base operators and wrote the full +current-column/all-size proof. Native recipes and phases are credited +to the native worker. Normal/-O pass all20 actual Gaussian cases: +N, all18 primal/dualQ operators, and a monomial control. + +For any one unary queryU, write `C G=F diag(U,I)`. The untouched column +forces `Q*g0` free, then `N*g1` free. In any fixed finite uniform-tensor +physical-monomial dictionary, ray disjointness and eventual tensor +independence force both entries zero. ThusG is singular. This applies +to arbitrary rational GL endpoints and arbitraryU, not just the +smallR0 endpoint gate in `REFLECTION-PAIR-COMPLETION.json`. + +An independent actual-matrix uncertainty proof also permits arbitrary +nonuniform physical monomial controllers. Here every native column +has4^f nonzero entries of modulus2^-f. If endpoint block columns have +supportsKF/KG, one query requires `KF*KG>=4^f`. Endpoint scalar bank +ADD counts consequently satisfy `aF+aG>=2f`. This closes any fixed-scan +one-query all-size implementation, while explicitly permitting a +growingO(f)ADD word. Any finite h additional M-sized restored identity +helper banks do not evade the untouched-column dimension argument +when the one queried bank is M-sized: the unqueried input dimension +is (h+1)M and the helper image dimension is hM. For variable helper +widths totaling K, the dimension step remains valid after the same +carrier-row vanishing if the query width w<=M. An arbitrarily wider +single queried helper bank is outside this claim. + +This precise2f ADD bound is for the triangularC gate. No identical +constant is asserted for a balanced/projector variant without its +own support derivation. No complete-caller lower bound is inferred +from this local obstruction. + +## Reproduction and remaining obligation + +A final independent audit of the native worker's changed even-parity +source response is in `INDEPENDENT-EVEN-PARITY-SOURCE.md/.json` and +`even_parity_source_independent.py`. It proves J_f²=-I, native arity2f, +and retainedJE full arity2Lf for allL>=2,f>=1. Actual64-column query +and endpoint recipes atL3 retain both adapters and exact Gaussian +phases. Omitting either adapter is rejected; replacing i^(f+1) by +constanti fails every oddf. Normal/-O pass. The incoming fullE anchor +remains paid, and no cheap-cleanup or caller-closure inference follows. +The same audit now closes monomial source-frame handoffs preserving +a monomial retarded gauge by the full-versus-cancelled source arity +contradiction. For monomial P with J=P Nj P^-1, the Clifford frame +drift E^-1 P^-1 E P has arity at least2f; the actual M chart has4f. +This does not exclude coupled-bank or cross-cut compensation. + +The native dual-reflection source later corrected only its prose +phase factors: ZHpZ=(-i)^fHq and ZHqZ=i^fHp. They cancel in MNiM; +the18 actual operators/recipes are unchanged. The one-query receipt +was regenerated against these current source pins and still passes. + +The final changed-continuation audit is `STAR-FACTORY-AUDIT.md/.json` +with producer `star_factory_audit.py`. Under its exact factored endpoint +assumptions, the evenA star has arity4f, FDu has4qf and FDv has(2q+4)f. +The factor-first retired-helper sum misses its gate by4f. Separate +completion toE costs(2q+8)f, exceeding prefix2qf. Current w readers +require post-retirement residualA and actual completedJb_r; there are +q-1 reverse updates including the final one. Independent exact polar +composition/inversion checks coverq2..64. This is a factored audit, +not a joint H/L lower bound or a complete physical all-q caller. + +Run producers from this directory with `python3 -B` or `python3 -O -B`. +The `--write` flag regenerates a receipt; omit it to compare exact +content. Main quick gates: + +``` +python3 -O -B one_query_endpoint_obstruction.py +python3 -O -B reflection_route_pruned.py +python3 -O -B reflection_route_pruned.py --dual +python3 -O -B reflection_pair_completion.py +python3 -O -B marked_residual_gate.py +python3 -O -B even_parity_source_independent.py +``` + +`EXTENSION-MANIFEST.json` lists the new owned files, their hashes and +the unchanged frozen-manifest hash. Current source pins in all new +receipts were checked against actual files. The original unpruned +five-query screens are longer checks; the exact pruned route replay +is the efficient equivalent for the two displayed fixed patterns. + +The constructive obligation remains an actual complete caller outside +the closed grammar: for example, a five-rank2f-query implementation +of `diag(E3,E3)` with all dyadic bridges, physical phases and endpoints +lowered, or a changed complete core whose compensation preserves a +positive stock gain. No such word is supplied here. Precision, owner +allocation and asymptotic transfer remain downstream obligations of +any future positive word. diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.json b/research/one-query-endpoint-scan/source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.json new file mode 100644 index 0000000000..db4c5d693b --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.json @@ -0,0 +1,456 @@ +{ + "all_size_binding": "N_f=i*H0^tensorf and each primal/dualQ_f=Q_1^tensorf. The exact base maximum1/2 gives maximum2^-f at everyf; all columns remain unitary.", + "attribution": "The independent-column obstruction and support-uncertainty proposal are from root. This file supplies the actual Gaussian base verification and the written all-size composition proof. Native arity and literal primal/dual recipes are from stabilizer_escape_1019.", + "exact_actual_base_cases": [ + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "f8b9c7d5a2e30866b1754385431ae09f129ad15a53d4c890a18dd822f5cd46c8", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "H0=-i*N0_1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "8f4c97b923e9d2177dff02532247018fb297f8c1e4d3c8d072ff533c956e9064", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection0_plane0" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "35d34f4396b5d56d4ccfe2eec2f2efceee71124460d33f9e4b5c5a46796ff79d", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection0_plane1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "07245862e904bcecd685fd184907acfe736d75a5d2aaa93ed7a1dd92a3bfa6ba", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection0_plane2" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "c4139255e45f7a39c07863c52985d2377bb188cf424c6587f9929359a4744b75", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection1_plane0" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "ccd24b0346cfeb38b9f14a27c13c9c277c64e3bb9783917c1ab0d5723d76dbf0", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection1_plane1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "d65759847758212a3dddef1194b4731fa9f7a35466e4630c3ceb0aa10ab7e954", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection1_plane2" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "beb6afe952d0f49ac30cd73092f2f098d3959d689087f3121cccde8be6c365a1", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection2_plane0" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "0b83ba051743a2c334f89500a630de6fdab6d3335994a988f25f13d0507bd767", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection2_plane1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "d8aebea53ffb3749826b01a5397c02060799e0dd6f621e23f243cc08b94de506", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "primal_Q_reflection2_plane2" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "cba327564c1321eccb12770d7063679630cf52592a8ac811fbe3dde2bebcddf7", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection0_plane0" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "639c811104480d819d6640ec97d4e3d6d03c3f1d524aca803e16861bb2c452e4", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection0_plane1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "565f916260a29347376a4c87a01e57527d4fc1a0de892426d536795745bd5d77", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection0_plane2" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "8a768cc5e734d9958742f9e41f984fc27ead821f58a335622e060f91dc851086", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection1_plane0" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "e3d92da143877b6afc325f86c770ee0978542c52ebd3fafd05a23b347ba03e14", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection1_plane1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "09d11809ab310d8b11e763620fdd8b937162fce0b9e85f8d4a476c7bbd7d6b7e", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection1_plane2" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "c4b9cbdb6727a85be2f0512aa9448ab84bcc2f37b88d2ab05296f93ba8cf30a4", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection2_plane0" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "a5cc7eef4fdf2151e16595c436fe5152813f9ace03421b57e18e180c88867cc3", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection2_plane1" + }, + { + "certificate": { + "column_support_histogram": { + "4": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "9f90385d1ba3a360f6e09ffda4a2a8867fdb08e5d269754ad165ece68aa12ba8", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1/4", + "nonzero_entry_squared_integer_norms": [ + 1024 + ] + }, + "kind": "native", + "name": "dual_Q_reflection2_plane2" + }, + { + "certificate": { + "column_support_histogram": { + "1": 64 + }, + "common_denominator": 64, + "exact_integer_matrix_sha256": "db64d7e97ae8bb889d3a94331f8198e338405e3fa99179a8951d16094580cb35", + "matrix_dimension": 64, + "maximum_entry_squared_modulus": "1", + "nonzero_entry_squared_integer_norms": [ + 4096 + ] + }, + "kind": "monomial", + "name": "R0_actual_ADDRESS_control" + } + ], + "exact_support_thresholds": [ + { + "f": 1, + "required_scalar_bank_ADDs_at_least": 2, + "required_support_product_at_least": 4 + }, + { + "f": 2, + "required_scalar_bank_ADDs_at_least": 4, + "required_support_product_at_least": 16 + }, + { + "f": 3, + "required_scalar_bank_ADDs_at_least": 6, + "required_support_product_at_least": 64 + }, + { + "f": 4, + "required_scalar_bank_ADDs_at_least": 8, + "required_support_product_at_least": 256 + }, + { + "f": 5, + "required_scalar_bank_ADDs_at_least": 10, + "required_support_product_at_least": 1024 + }, + { + "f": 6, + "required_scalar_bank_ADDs_at_least": 12, + "required_support_product_at_least": 4096 + }, + { + "f": 7, + "required_scalar_bank_ADDs_at_least": 14, + "required_support_product_at_least": 16384 + }, + { + "f": 8, + "required_scalar_bank_ADDs_at_least": 16, + "required_support_product_at_least": 65536 + }, + { + "f": 9, + "required_scalar_bank_ADDs_at_least": 18, + "required_support_product_at_least": 262144 + }, + { + "f": 10, + "required_scalar_bank_ADDs_at_least": 20, + "required_support_product_at_least": 1048576 + }, + { + "f": 11, + "required_scalar_bank_ADDs_at_least": 22, + "required_support_product_at_least": 4194304 + }, + { + "f": 12, + "required_scalar_bank_ADDs_at_least": 24, + "required_support_product_at_least": 16777216 + }, + { + "f": 13, + "required_scalar_bank_ADDs_at_least": 26, + "required_support_product_at_least": 67108864 + }, + { + "f": 14, + "required_scalar_bank_ADDs_at_least": 28, + "required_support_product_at_least": 268435456 + }, + { + "f": 15, + "required_scalar_bank_ADDs_at_least": 30, + "required_support_product_at_least": 1073741824 + }, + { + "f": 16, + "required_scalar_bank_ADDs_at_least": 32, + "required_support_product_at_least": 4294967296 + } + ], + "finite_uniform_theorem": "No one-query factorization C G=F diag(U,I) exists over a fixed finite uniform-tensor physical-monomial endpoint algebra for allf. U is arbitrary. Distinct nonproportional tensor rays are independent for all sufficiently large tensor powers, so Qg0 and Ng1 cannot both return to the monomial algebra unless the untouched column vanishes.", + "helper_dimension_contract": "For h additional M-dimensional identity helper banks and one M-dimensional queried bank, unqueried input dimension (h+1)M exceeds helper image dimension hM. More generally, after the same carrier-row vanishing, helper widths totaling K and query width w<=M give 2M+K-w>=M+K>K. No arbitrarily larger single queried helper bank is admitted.", + "limits": [ + "The nonuniform theorem is a support/scan lower bound, not an impossibility result forO(f)ADD words.", + "Finite uniform tensor independence does not itself cover f-dependent growing nonuniform controllers.", + "The gate is unary on one physical bank. Multi-bank native primitives or nonmonomial free endpoints are outside the premise.", + "The helper dimension argument requires an M-dimensional queried bank, or query width<=M in the stated conditional variable-width extension; unbounded queried helper width is excluded.", + "This is a scoped obstruction for the changed localC gate, not a complete-caller stock floor in the enlarged reflection grammar." + ], + "no_new_kappa": true, + "nonuniform_support_theorem": "For arbitrary physical monomial controllers, if endpoint block columns have at mostK_G andK_F nonzero entries, a one-query factorization requiresK_G*K_F>=2^(2f). Consequently scalar bank ADD counts obeya_F+a_G>=2f. A growingO(f)ADD word is not excluded.", + "producer_sha256": "398ae61a6c59c86f0c41c8b2bcbdd60ce9dafacb410a3071fd68e27d427c5384", + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/unpaired_reflection_screen.py", + "sha256": "cc385b510da37946acc0f9882f74d30f3431e8c9ef9e99dd5699aeaa81ec531e" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/varied_reflection_screen.py", + "sha256": "59fe8f29770c7ec7e75b5ab29716f1dd7a35404e74919e5370bc04cc2df41c86" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/reflection_route_pruned.py", + "sha256": "63c6d8a2d6ab986138cade152b8279de20865f95dd0a2c270024c4dfd9575ae4" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-REFLECTION.json", + "sha256": "15980d81733f121d23f7e95f1fb50aa3dccfdc67fb79794b4a93e34f8874293f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/dual_reflections.py", + "sha256": "b836c6e08e630518a4e11819e5463fc67faaa3c2fc137f13f1dc376a7f6afd82" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/DUAL-REFLECTIONS.json", + "sha256": "efcdb1dc157eb0d4d3ac89b390100bc602134ae3d6d4026ce162a5af50d59b59" + } + ], + "status": "PASS_ACTUAL_GAUSSIAN_ONE_QUERY_ENDPOINT_OBSTRUCTION", + "target": "C=[[Q-I,N],[Q,0]], two independent M-dimensional carrier banks; optionally any finite h additional M-dimensional restored identity helper banks, with one query on an M-dimensional bank." +} diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.md b/research/one-query-endpoint-scan/source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.md new file mode 100644 index 0000000000..a8e5dadac8 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.md @@ -0,0 +1,144 @@ +# A one-query obstruction for the changed two-carrier gate + +The current carrier map is + +\[ +C_f=\begin{pmatrix}Q_f-I&N_f\\Q_f&0\end{pmatrix}, +\] + +on two arbitrary independent banks, each of physical dimension +\(M\). Here both \(Q_f\) and \(N_f\) are +unitary and nonmonomial in the **physical** coordinate basis. For the +actual admitted primal and dual reflections, +\(Q_f=N_iR_jN_i^{-1}\) or \(N_iS_jN_i^{-1}\), each has native arity +\(2f\), and the actual common native \(N_f\) also has arity \(2f\). +No original-input reader or initialized bank is assumed. + +Suppose one unary query, on bank0, implemented this map between free +invertible endpoints. Equivalently, + +\[ +C_fG_f=F_f\operatorname{diag}(U_f,I). +\] + +The second column of the right side is free. Writing the second column +of \(G_f\) as \((g_0,g_1)^T\), the bottom equation is +\(Q_fg_0\in\mathcal A_f\). Once this forces \(g_0=0\), the top equation +is \(N_fg_1\in\mathcal A_f\). If this also forces \(g_1=0\), then +\(G_f\) is singular. A query on bank1 instead leaves the first column +untouched and gives exactly the same contradiction. The argument does +not depend on \(U_f\), its rank, its phase or its native recipe. + +## Fixed finite uniform tensor endpoints + +Let \(H\) be a fixed finite set of distinct rays of invertible physical +monomial base matrices. Its members act at sizef by their tensor powers; +scalar Gaussian phases may be absorbed into arbitrary scalar +coefficients. Let \(\mathcal A_f\) be their linear span. The endpoints +may have arbitrary coefficients depending onf. + +If a base matrix \(Q\) is nonmonomial, no \(Qh\), for \(h\in H\), is +proportional to a physical monomial: right multiplication by a monomial +only permutes and rescales columns. The rays \(Qh\) are also distinct +from each other. Thus the two finite ray sets \(QH\) and \(H\) are +disjoint. Distinct nonproportional vectors have linearly independent +tensor powers for every sufficiently large degree. An explicit proof +chooses, for each rayi, a product of linear forms that kills every other +ray but does not kill rayi; multiplying by another nonvanishing linear +form raises this separating polynomial to any larger degree. For at +most \(2|H|\) rays, degree \(2|H|-1\) suffices. + +Consequently \(Q_fg_0\in\mathcal A_f\) implies \(g_0=0\) for every +sufficiently largef. The same holds for \(N_f\). This excludes a +one-query factorization valid for allf in this endpoint algebra. It +holds separately in every Gaussian phase residue, and allows arbitrary +f-dependent scalar endpoint coefficients. It uses independence of +tensor rays, rather than linear independence of the matrices atf1. + +This theorem covers finite groups of uniform tensor physical monomials +and their full group-algebra GL endpoints. It does not, by itself, +cover a sequence of growing nonuniform controllers whose support is +not contained in one fixed finite base-ray set. + +## Arbitrary physical monomial controllers: an actual scan bound + +There is an independent argument that allows nonuniform controllers. +For any unitary matrixQ with maximum entry modulus \(\mu\), and any +nonzero vectorx, Cauchy's inequality gives + +\[ +|\operatorname{supp}x|\,|\operatorname{supp}Qx|\ge\mu^{-2}. +\] + +Indeed every output coordinate has modulus at most +\(\mu\sqrt{|\operatorname{supp}x|}\|x\|_2\); summing its square over +the output support and using unitarity proves the claim. + +Assume every physical column of each endpoint block has support at +most \(K_G\) or \(K_F\), respectively. Apply this inequality separately +to every physical input column of \(Q_fg_0\) and \(N_fg_1\). If + +\[ +K_GK_F<\min(\mu_{Q_f}^{-2},\mu_{N_f}^{-2}), +\] + +both vectors must vanish, so the same untouched-column contradiction +applies. Therefore a one-query factorization requires the reverse +weak inequality. + +The accompanying exact Gaussian calculation conjugates the actual +one-bit X-character monomials by the64-point Walsh matrix. ForN and +all18 primal/dualQ operators, every physical column has exactly4 +nonzero entries, all of modulus1/2. All64 columns are independently +checked orthonormal with integer Gaussian arithmetic. The native +tensor recipes give \(\mu_{Q_f}=\mu_{N_f}=2^{-f}\) exactly. Hence + +\[ +K_GK_F\ge 2^{2f}. +\] + +A physical bank ADDRESS or Pauli monomial preserves column support. +Each scalar bank ADD can at most double the support of a full bank +column. If the endpoint words use \(a_G\) and \(a_F\) such ADDs, then +\(K_G\le2^{a_G}\), \(K_F\le2^{a_F}\), and necessarily + +\[ +a_G+a_F\ge2f. +\] + +This proves that no fixed number of actual dyadic scalar ADD/ADDRESS/ +Pauli bridges gives a one-query all-size implementation ofC. It permits +a growing \(O(f)\) ADD word; it does not silently declare those scans +free. + +The helper extension permits any finite number \(h\) of additional +restored identity banks, each also of dimension \(M\), with the single +query acting on one \(M\)-dimensional bank. All unqueried columns have zero entries in +both carrier rows. Their input subspace has dimension \((h+1)M\), but +their image under \(G\) lies in the helper rows, of total dimension \(hM\). +Thus \(G\) cannot be injective. This argument allows arbitrary independent +dirty inputs in every helper bank; it does not assume zero helpers. + +For variable helper dimensions of total \(K\), the same dimension step +works whenever the query width \(w\le M\), provided the preceding +carrier-row vanishing applies to every unqueried physical column: +the unqueried input dimension is \(2M+K-w\ge M+K>K\), while its image +is confined to the \(K\) helper coordinates. No claim here permits an +arbitrarily larger single queried helper bank. The restriction on +query width is essential to this dimension argument. + +## Scope, attribution and remaining obligations + +The root supplied the untouched-column argument and its independent +support-uncertainty refinement. The native worker supplied the actual +single-query primal/dual recipes, exact Gaussian phases and arities. +The present composition check supplies the full current-column proof, +the all-size tensor/sparsity arguments and the independent actual-base +Gaussian certificate. These are written proofs supported by finite +exact calculations, not formal-kernel proofs. + +This result closes the one-query version of this particular changed +localC gate under the stated endpoint contracts. It does not establish +a full-caller stock floor for the enlarged reflection grammar or rule +out a different jointly compensated caller. No positive five-query +two-bank caller, owner allocation or asymptotic improvement is claimed. diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/PRUNED-VARIED-REPLAY.json b/research/one-query-endpoint-scan/source/q4-pauli-fusion/PRUNED-VARIED-REPLAY.json new file mode 100644 index 0000000000..0ff4739729 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/PRUNED-VARIED-REPLAY.json @@ -0,0 +1,364 @@ +{ + "ADDRESS_definition": "Rj transvection vector allp+qj; Sj vector allq+pj. Both act bitwise at allf. Enlarged endpoints additionally admit independent S3 permutations ofp/q chunks.", + "X_character_orbits": [ + [ + 0 + ], + [ + 1, + 4, + 7, + 13, + 16, + 19, + 22, + 25, + 28, + 37, + 49, + 52 + ], + [ + 2, + 8, + 21, + 32 + ], + [ + 3, + 6, + 9, + 12, + 15, + 18, + 24, + 27, + 30, + 33, + 36, + 39, + 45, + 48, + 51, + 54, + 57, + 60 + ], + [ + 5, + 17, + 20 + ], + [ + 10, + 23, + 29, + 34, + 40, + 53 + ], + [ + 11, + 14, + 26, + 35, + 38, + 41, + 44, + 47, + 50, + 56, + 59, + 62 + ], + [ + 31, + 42, + 55, + 61 + ], + [ + 43, + 46, + 58 + ], + [ + 63 + ] + ], + "all_f_binding": "Ni,f=i*(-i*Ni,1)^tensorf. All ADDRESSs and admitted Ai/B queries tensor-lift their exact one-bit monomials. Gaussian proportional-ray phases are folded separately for all4 residues; no f1-only linear relation is used.", + "all_residue_word_hits": [], + "bank_pattern": [ + 0, + 1, + 0, + 1, + 0 + ], + "controls": [ + "Sixteen pruned actual prefixes checked against all26 unpruned last-query completions in all4 residues.", + "Exact target diag(E3,E3) accepted by row prune and full unitary endpoint test in all4 residues." + ], + "counts": { + "all_last_queries_pruned_prefixes": 456976, + "covered_five_query_words": 11881376, + "four_query_prefixes": 456976, + "pruned_controls": 16 + }, + "exact_free_ADDRESS_group_order": 144, + "exact_scope": "Five queries; fixed alternating banks and the displayed four W routes; query alphabet exactly the serialized26 signed choices; arbitrary outer GL2 over the displayed complete finite ADDRESS group. Additional internal scalar/Pauli/ADDRESS bridges and other bank/route patterns are untested.", + "hits_by_f_mod4": { + "0": [], + "1": [], + "2": [], + "3": [] + }, + "no_new_kappa": true, + "paid_native_tariff": "Each Ni, Aij=NiRjNi^-1 and B=N0R0P2R0N0^-1 is one independently admitted rank2f child with its literal monomial adapters. No dual conjugate query is assumed.", + "producer_sha256": "63c6d8a2d6ab986138cade152b8279de20865f95dd0a2c270024c4dfd9575ae4", + "prune_proof": "Final query acts only onbank0. The two bank1 entries are unchanged, so their nonaccepted tensor rays cannot be repaired. Distinct base rays have independent sufficiently high tensor powers in each residue class. The row test is a necessary all-f condition, not a heuristic.", + "query_alphabet": [ + { + "kind": "N", + "negative": false, + "operator": 1, + "plane": 0, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 1, + "plane": 0, + "scalar_phase": 3 + }, + { + "kind": "N", + "negative": false, + "operator": 2, + "plane": 1, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 2, + "plane": 1, + "scalar_phase": 3 + }, + { + "kind": "N", + "negative": false, + "operator": 3, + "plane": 2, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 3, + "plane": 2, + "scalar_phase": 3 + }, + { + "kind": "A", + "negative": false, + "operator": 9, + "plane": 0, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 9, + "plane": 0, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 11, + "plane": 1, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 11, + "plane": 1, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 13, + "plane": 2, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 13, + "plane": 2, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 299, + "plane": 0, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 299, + "plane": 0, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 301, + "plane": 1, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 301, + "plane": 1, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 303, + "plane": 2, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 303, + "plane": 2, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 305, + "plane": 0, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 305, + "plane": 0, + "reflection": 2, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 307, + "plane": 1, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 307, + "plane": 1, + "reflection": 2, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 309, + "plane": 2, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 309, + "plane": 2, + "reflection": 2, + "scalar_phase": 2 + }, + { + "ADDRESS_plane_swap": 2, + "kind": "B_full_conjugate", + "negative": false, + "operator": 311, + "plane": 0, + "reflection": 0, + "scalar_phase": 0 + }, + { + "ADDRESS_plane_swap": 2, + "kind": "B_full_conjugate", + "negative": true, + "operator": 311, + "plane": 0, + "reflection": 0, + "scalar_phase": 2 + } + ], + "route_pattern": [ + "R0", + "R1", + "R2", + "R0" + ], + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/unpaired_reflection_screen.py", + "sha256": "cc385b510da37946acc0f9882f74d30f3431e8c9ef9e99dd5699aeaa81ec531e" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/varied_reflection_screen.py", + "sha256": "59fe8f29770c7ec7e75b5ab29716f1dd7a35404e74919e5370bc04cc2df41c86" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-REFLECTION.json", + "sha256": "15980d81733f121d23f7e95f1fb50aa3dccfdc67fb79794b4a93e34f8874293f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_factory.py", + "sha256": "81a75479e21d70181e4aa70746be3a4a31bcb3ddd1bd00a4a1b812bf126d7caf" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-FACTORY.json", + "sha256": "dc3a105b7ce7d226aeb8996aea6454ee66d65d9b9529af159d417f00bec02d34" + } + ], + "status": "PASS_EXACT_PRUNED_VARIED_ROUTE_REPLAY", + "target": "diag(E3,E3), everyf>=1, arbitrary independent inputs" +} diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/UNPAIRED-REFLECTION-SCREEN.json b/research/one-query-endpoint-scan/source/q4-pauli-fusion/UNPAIRED-REFLECTION-SCREEN.json new file mode 100644 index 0000000000..6b568ec635 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/UNPAIRED-REFLECTION-SCREEN.json @@ -0,0 +1,61 @@ +{ + "all_f_tensor_proof": "On one bit per chunk H_i=-i*N_i,1 is the exact X-character monomial w->w xor{p_i,q_i} with phasei^(-w_pi+w_qi). For everyf, N_i,f=i*H_i^tensorf. R_f=R_1^tensorf. Matrix entries of the screened word are finite Gaussian dyadic sums of tensor powers of the represented base monomials. Equality after grouping exact monomial rays and theiri^(f mod4) phases is therefore an exact all-f identity; f1-only linear relations between distinct monomials are never accepted. A found completion uses only I,R and Gaussian dyadic scalars and is checked unitary in bothR sectors.", + "all_residue_word_hits": 0, + "complete_word_hits": [], + "fused_native_A": "A_i,f=(H_i R H_i)^tensorf, with no outside i factor. Native worker independently supplies its single-rank2f literal query and monomial adapters; the group identity by itself does not establish this tariff.", + "grammar": "Exactly five unary queries, each chosen from +/-N_i and +/-A_i on all3planes/eitherbank, where A_i=N_i R N_i^-1 has independently admitted native rank2f and is charged ONCE. Exactly W(R) occurs between consecutive queries. Arbitrary outer GL2(Q(i)[R]) completion is accepted separately for eachf mod4. All24^5 patterns are covered; additional internal Z, other scalar bank phases, other reflections or general bitlinear ADDRESS words are outside this screen.", + "group_model": { + "cached_left_products": 897, + "dimension": 64, + "exact_base_monomials": 128, + "exact_base_rays": 128 + }, + "hits_by_f_mod4": { + "0": [], + "1": [], + "2": [], + "3": [] + }, + "marked_escape": { + "input_X_character": 2, + "input_residual_labels": [ + 1, + 0, + 0 + ], + "output_X_character": 21, + "output_residual_labels": [ + 1, + 1, + 1 + ] + }, + "native_words": 7962624, + "necessity_for_this_finite_grammar": "Distinct nonproportional base-operator vectors have linearly independent f-th tensor powers once f is sufficiently large: choose, for each vector, a product of linear forms annihilating every other vector. For each fixed fmod4 the same argument applies after absorbing Gaussian ray phases. Thus the ray-support failure is an all-f obstruction within this finite word grammar, even if the outer scalar coefficients are allowed to depend onf.", + "negative_controls": [ + "A genuine f1 matrix identity S=(1+i)I/2+(1-i)Z/2 fails its coefficientwise tensor lift on f2 input11: actual -1, false lift +1.", + "The unpaired R sends one residual mark to three and is explicitly outside the marked-C invariant block." + ], + "no_new_kappa": true, + "producer_sha256": "cc385b510da37946acc0f9882f74d30f3431e8c9ef9e99dd5699aeaa81ec531e", + "reflection": "R=P_A bitwise overf; A=I+vvT, v=(p0,q0,p1,p2). It is orthogonal, involutive, and commutes fullE3 exactly. TypedD^-1P_A D=P_A because three selected chunks arep and oneq.", + "residue_completion_hits": 0, + "scope": "A zero-hit result is exhaustive only for this specified internal-routing grammar and its declared outer completions; it is not a global lower bound for full Pauli or arbitrary ADDRESS bridges.", + "singleton_ray_rejections": 7962624, + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/native_model.py", + "sha256": "6397a86bd3d1461be182fcfa8602b0c70c489964a8c14f12436ba2506e11d9e3" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/conjugated_reflection.py", + "sha256": "6b68a4a60b160fe28227c31909ed86bd7f80b1f3e07591032cd001dbeb242f6f" + }, + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/native-frames/CONJUGATED-REFLECTION.json", + "sha256": "15980d81733f121d23f7e95f1fb50aa3dccfdc67fb79794b4a93e34f8874293f" + } + ], + "status": "PASS_EXACT_BOUNDED_UNPAIRED_REFLECTION_SCREEN", + "target": "diag(E3,E3), E3=N0*N1*N2, six native planes of stock across two banks; desired5H2 instead of6H2." +} diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/VARIED-REFLECTION-SCREEN.json b/research/one-query-endpoint-scan/source/q4-pauli-fusion/VARIED-REFLECTION-SCREEN.json new file mode 100644 index 0000000000..e2959c3c09 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/VARIED-REFLECTION-SCREEN.json @@ -0,0 +1,10193 @@ +{ + "all_f_proof": "Uses the exact tensor-base and Gaussian phase folding of unpaired_reflection_screen.py. Every accepted endpoint is over the complete generated native-zero ADDRESS group, not a short palette. E3 commutes that group, so arbitrary left/right GL2 endpoints reduce to the tested right completion. Distinct tensor rays are not identified using f1 linear relations. Every admitted Aij and the full conjugateB is charged once using its independent physical native recipe.", + "all_residue_word_hits": 0, + "bank_pattern": [ + 0, + 1, + 0, + 1, + 0 + ], + "complete_word_hits": [], + "exact_free_outer_ADDRESS_group_order": 144, + "free_outer_group_generators": "Whole-plane swaps P01/P02 and the3 unpaired reflections Rj withvj=p0+p1+p2+qj.", + "free_outer_group_operators": [ + { + "X_character_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "index": 0 + }, + { + "X_character_permutation": [ + 0, + 22, + 21, + 3, + 19, + 5, + 6, + 16, + 8, + 30, + 29, + 11, + 27, + 13, + 14, + 24, + 7, + 17, + 18, + 4, + 20, + 2, + 1, + 23, + 15, + 25, + 26, + 12, + 28, + 10, + 9, + 31, + 32, + 54, + 53, + 35, + 51, + 37, + 38, + 48, + 40, + 62, + 61, + 43, + 59, + 45, + 46, + 56, + 39, + 49, + 50, + 36, + 52, + 34, + 33, + 55, + 47, + 57, + 58, + 44, + 60, + 42, + 41, + 63 + ], + "index": 4 + }, + { + "X_character_permutation": [ + 0, + 28, + 2, + 30, + 25, + 5, + 27, + 7, + 21, + 9, + 23, + 11, + 12, + 16, + 14, + 18, + 13, + 17, + 15, + 19, + 20, + 8, + 22, + 10, + 24, + 4, + 26, + 6, + 1, + 29, + 3, + 31, + 32, + 60, + 34, + 62, + 57, + 37, + 59, + 39, + 53, + 41, + 55, + 43, + 44, + 48, + 46, + 50, + 45, + 49, + 47, + 51, + 52, + 40, + 54, + 42, + 56, + 36, + 58, + 38, + 33, + 61, + 35, + 63 + ], + "index": 14 + }, + { + "X_character_permutation": [ + 0, + 52, + 2, + 54, + 49, + 5, + 51, + 7, + 8, + 60, + 10, + 62, + 57, + 13, + 59, + 15, + 37, + 17, + 39, + 19, + 20, + 32, + 22, + 34, + 45, + 25, + 47, + 27, + 28, + 40, + 30, + 42, + 21, + 33, + 23, + 35, + 36, + 16, + 38, + 18, + 29, + 41, + 31, + 43, + 44, + 24, + 46, + 26, + 48, + 4, + 50, + 6, + 1, + 53, + 3, + 55, + 56, + 12, + 58, + 14, + 9, + 61, + 11, + 63 + ], + "index": 15 + }, + { + "X_character_permutation": [ + 0, + 4, + 8, + 12, + 1, + 5, + 9, + 13, + 2, + 6, + 10, + 14, + 3, + 7, + 11, + 15, + 16, + 20, + 24, + 28, + 17, + 21, + 25, + 29, + 18, + 22, + 26, + 30, + 19, + 23, + 27, + 31, + 32, + 36, + 40, + 44, + 33, + 37, + 41, + 45, + 34, + 38, + 42, + 46, + 35, + 39, + 43, + 47, + 48, + 52, + 56, + 60, + 49, + 53, + 57, + 61, + 50, + 54, + 58, + 62, + 51, + 55, + 59, + 63 + ], + "index": 16 + }, + { + "X_character_permutation": [ + 0, + 16, + 32, + 48, + 4, + 20, + 36, + 52, + 8, + 24, + 40, + 56, + 12, + 28, + 44, + 60, + 1, + 17, + 33, + 49, + 5, + 21, + 37, + 53, + 9, + 25, + 41, + 57, + 13, + 29, + 45, + 61, + 2, + 18, + 34, + 50, + 6, + 22, + 38, + 54, + 10, + 26, + 42, + 58, + 14, + 30, + 46, + 62, + 3, + 19, + 35, + 51, + 7, + 23, + 39, + 55, + 11, + 27, + 43, + 59, + 15, + 31, + 47, + 63 + ], + "index": 17 + }, + { + "X_character_permutation": [ + 0, + 22, + 8, + 30, + 19, + 5, + 27, + 13, + 21, + 3, + 29, + 11, + 6, + 16, + 14, + 24, + 7, + 17, + 15, + 25, + 20, + 2, + 28, + 10, + 18, + 4, + 26, + 12, + 1, + 23, + 9, + 31, + 32, + 54, + 40, + 62, + 51, + 37, + 59, + 45, + 53, + 35, + 61, + 43, + 38, + 48, + 46, + 56, + 39, + 49, + 47, + 57, + 52, + 34, + 60, + 42, + 50, + 36, + 58, + 44, + 33, + 55, + 41, + 63 + ], + "index": 18 + }, + { + "X_character_permutation": [ + 0, + 22, + 32, + 54, + 19, + 5, + 51, + 37, + 8, + 30, + 40, + 62, + 27, + 13, + 59, + 45, + 7, + 17, + 39, + 49, + 20, + 2, + 52, + 34, + 15, + 25, + 47, + 57, + 28, + 10, + 60, + 42, + 21, + 3, + 53, + 35, + 6, + 16, + 38, + 48, + 29, + 11, + 61, + 43, + 14, + 24, + 46, + 56, + 18, + 4, + 50, + 36, + 1, + 23, + 33, + 55, + 26, + 12, + 58, + 44, + 9, + 31, + 41, + 63 + ], + "index": 19 + }, + { + "X_character_permutation": [ + 0, + 25, + 21, + 12, + 28, + 5, + 9, + 16, + 2, + 27, + 23, + 14, + 30, + 7, + 11, + 18, + 13, + 20, + 24, + 1, + 17, + 8, + 4, + 29, + 15, + 22, + 26, + 3, + 19, + 10, + 6, + 31, + 32, + 57, + 53, + 44, + 60, + 37, + 41, + 48, + 34, + 59, + 55, + 46, + 62, + 39, + 43, + 50, + 45, + 52, + 56, + 33, + 49, + 40, + 36, + 61, + 47, + 54, + 58, + 35, + 51, + 42, + 38, + 63 + ], + "index": 20 + }, + { + "X_character_permutation": [ + 0, + 37, + 21, + 48, + 49, + 20, + 36, + 1, + 8, + 45, + 29, + 56, + 57, + 28, + 44, + 9, + 52, + 17, + 33, + 4, + 5, + 32, + 16, + 53, + 60, + 25, + 41, + 12, + 13, + 40, + 24, + 61, + 2, + 39, + 23, + 50, + 51, + 22, + 38, + 3, + 10, + 47, + 31, + 58, + 59, + 30, + 46, + 11, + 54, + 19, + 35, + 6, + 7, + 34, + 18, + 55, + 62, + 27, + 43, + 14, + 15, + 42, + 26, + 63 + ], + "index": 21 + }, + { + "X_character_permutation": [ + 0, + 28, + 21, + 9, + 25, + 5, + 12, + 16, + 2, + 30, + 23, + 11, + 27, + 7, + 14, + 18, + 13, + 17, + 24, + 4, + 20, + 8, + 1, + 29, + 15, + 19, + 26, + 6, + 22, + 10, + 3, + 31, + 32, + 60, + 53, + 41, + 57, + 37, + 44, + 48, + 34, + 62, + 55, + 43, + 59, + 39, + 46, + 50, + 45, + 49, + 56, + 36, + 52, + 40, + 33, + 61, + 47, + 51, + 58, + 38, + 54, + 42, + 35, + 63 + ], + "index": 22 + }, + { + "X_character_permutation": [ + 0, + 28, + 2, + 30, + 25, + 5, + 27, + 7, + 32, + 60, + 34, + 62, + 57, + 37, + 59, + 39, + 13, + 17, + 15, + 19, + 20, + 8, + 22, + 10, + 45, + 49, + 47, + 51, + 52, + 40, + 54, + 42, + 21, + 9, + 23, + 11, + 12, + 16, + 14, + 18, + 53, + 41, + 55, + 43, + 44, + 48, + 46, + 50, + 24, + 4, + 26, + 6, + 1, + 29, + 3, + 31, + 56, + 36, + 58, + 38, + 33, + 61, + 35, + 63 + ], + "index": 23 + }, + { + "X_character_permutation": [ + 0, + 19, + 8, + 27, + 22, + 5, + 30, + 13, + 21, + 6, + 29, + 14, + 3, + 16, + 11, + 24, + 7, + 20, + 15, + 28, + 17, + 2, + 25, + 10, + 18, + 1, + 26, + 9, + 4, + 23, + 12, + 31, + 32, + 51, + 40, + 59, + 54, + 37, + 62, + 45, + 53, + 38, + 61, + 46, + 35, + 48, + 43, + 56, + 39, + 52, + 47, + 60, + 49, + 34, + 57, + 42, + 50, + 33, + 58, + 41, + 36, + 55, + 44, + 63 + ], + "index": 24 + }, + { + "X_character_permutation": [ + 0, + 13, + 32, + 45, + 25, + 20, + 57, + 52, + 21, + 24, + 53, + 56, + 12, + 1, + 44, + 33, + 28, + 17, + 60, + 49, + 5, + 8, + 37, + 40, + 9, + 4, + 41, + 36, + 16, + 29, + 48, + 61, + 2, + 15, + 34, + 47, + 27, + 22, + 59, + 54, + 23, + 26, + 55, + 58, + 14, + 3, + 46, + 35, + 30, + 19, + 62, + 51, + 7, + 10, + 39, + 42, + 11, + 6, + 43, + 38, + 18, + 31, + 50, + 63 + ], + "index": 25 + }, + { + "X_character_permutation": [ + 0, + 52, + 21, + 33, + 49, + 5, + 36, + 16, + 8, + 60, + 29, + 41, + 57, + 13, + 44, + 24, + 37, + 17, + 48, + 4, + 20, + 32, + 1, + 53, + 45, + 25, + 56, + 12, + 28, + 40, + 9, + 61, + 2, + 54, + 23, + 35, + 51, + 7, + 38, + 18, + 10, + 62, + 31, + 43, + 59, + 15, + 46, + 26, + 39, + 19, + 50, + 6, + 22, + 34, + 3, + 55, + 47, + 27, + 58, + 14, + 30, + 42, + 11, + 63 + ], + "index": 26 + }, + { + "X_character_permutation": [ + 0, + 52, + 2, + 54, + 49, + 5, + 51, + 7, + 21, + 33, + 23, + 35, + 36, + 16, + 38, + 18, + 37, + 17, + 39, + 19, + 20, + 32, + 22, + 34, + 48, + 4, + 50, + 6, + 1, + 53, + 3, + 55, + 8, + 60, + 10, + 62, + 57, + 13, + 59, + 15, + 29, + 41, + 31, + 43, + 44, + 24, + 46, + 26, + 45, + 25, + 47, + 27, + 28, + 40, + 30, + 42, + 56, + 12, + 58, + 14, + 9, + 61, + 11, + 63 + ], + "index": 27 + }, + { + "X_character_permutation": [ + 0, + 49, + 8, + 57, + 52, + 5, + 60, + 13, + 2, + 51, + 10, + 59, + 54, + 7, + 62, + 15, + 37, + 20, + 45, + 28, + 17, + 32, + 25, + 40, + 39, + 22, + 47, + 30, + 19, + 34, + 27, + 42, + 21, + 36, + 29, + 44, + 33, + 16, + 41, + 24, + 23, + 38, + 31, + 46, + 35, + 18, + 43, + 26, + 48, + 1, + 56, + 9, + 4, + 53, + 12, + 61, + 50, + 3, + 58, + 11, + 6, + 55, + 14, + 63 + ], + "index": 28 + }, + { + "X_character_permutation": [ + 0, + 7, + 32, + 39, + 19, + 20, + 51, + 52, + 8, + 15, + 40, + 47, + 27, + 28, + 59, + 60, + 22, + 17, + 54, + 49, + 5, + 2, + 37, + 34, + 30, + 25, + 62, + 57, + 13, + 10, + 45, + 42, + 21, + 18, + 53, + 50, + 6, + 1, + 38, + 33, + 29, + 26, + 61, + 58, + 14, + 9, + 46, + 41, + 3, + 4, + 35, + 36, + 16, + 23, + 48, + 55, + 11, + 12, + 43, + 44, + 24, + 31, + 56, + 63 + ], + "index": 29 + }, + { + "X_character_permutation": [ + 0, + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 1, + 5, + 9, + 13, + 17, + 21, + 25, + 29, + 33, + 37, + 41, + 45, + 49, + 53, + 57, + 61, + 2, + 6, + 10, + 14, + 18, + 22, + 26, + 30, + 34, + 38, + 42, + 46, + 50, + 54, + 58, + 62, + 3, + 7, + 11, + 15, + 19, + 23, + 27, + 31, + 35, + 39, + 43, + 47, + 51, + 55, + 59, + 63 + ], + "index": 30 + }, + { + "X_character_permutation": [ + 0, + 16, + 32, + 48, + 1, + 17, + 33, + 49, + 2, + 18, + 34, + 50, + 3, + 19, + 35, + 51, + 4, + 20, + 36, + 52, + 5, + 21, + 37, + 53, + 6, + 22, + 38, + 54, + 7, + 23, + 39, + 55, + 8, + 24, + 40, + 56, + 9, + 25, + 41, + 57, + 10, + 26, + 42, + 58, + 11, + 27, + 43, + 59, + 12, + 28, + 44, + 60, + 13, + 29, + 45, + 61, + 14, + 30, + 46, + 62, + 15, + 31, + 47, + 63 + ], + "index": 31 + }, + { + "X_character_permutation": [ + 0, + 1, + 8, + 9, + 4, + 5, + 12, + 13, + 2, + 3, + 10, + 11, + 6, + 7, + 14, + 15, + 16, + 17, + 24, + 25, + 20, + 21, + 28, + 29, + 18, + 19, + 26, + 27, + 22, + 23, + 30, + 31, + 32, + 33, + 40, + 41, + 36, + 37, + 44, + 45, + 34, + 35, + 42, + 43, + 38, + 39, + 46, + 47, + 48, + 49, + 56, + 57, + 52, + 53, + 60, + 61, + 50, + 51, + 58, + 59, + 54, + 55, + 62, + 63 + ], + "index": 32 + }, + { + "X_character_permutation": [ + 0, + 22, + 8, + 30, + 19, + 5, + 27, + 13, + 32, + 54, + 40, + 62, + 51, + 37, + 59, + 45, + 7, + 17, + 15, + 25, + 20, + 2, + 28, + 10, + 39, + 49, + 47, + 57, + 52, + 34, + 60, + 42, + 21, + 3, + 29, + 11, + 6, + 16, + 14, + 24, + 53, + 35, + 61, + 43, + 38, + 48, + 46, + 56, + 18, + 4, + 26, + 12, + 1, + 23, + 9, + 31, + 50, + 36, + 58, + 44, + 33, + 55, + 41, + 63 + ], + "index": 33 + }, + { + "X_character_permutation": [ + 0, + 25, + 2, + 27, + 28, + 5, + 30, + 7, + 21, + 12, + 23, + 14, + 9, + 16, + 11, + 18, + 13, + 20, + 15, + 22, + 17, + 8, + 19, + 10, + 24, + 1, + 26, + 3, + 4, + 29, + 6, + 31, + 32, + 57, + 34, + 59, + 60, + 37, + 62, + 39, + 53, + 44, + 55, + 46, + 41, + 48, + 43, + 50, + 45, + 52, + 47, + 54, + 49, + 40, + 51, + 42, + 56, + 33, + 58, + 35, + 36, + 61, + 38, + 63 + ], + "index": 34 + }, + { + "X_character_permutation": [ + 0, + 37, + 8, + 45, + 49, + 20, + 57, + 28, + 21, + 48, + 29, + 56, + 36, + 1, + 44, + 9, + 52, + 17, + 60, + 25, + 5, + 32, + 13, + 40, + 33, + 4, + 41, + 12, + 16, + 53, + 24, + 61, + 2, + 39, + 10, + 47, + 51, + 22, + 59, + 30, + 23, + 50, + 31, + 58, + 38, + 3, + 46, + 11, + 54, + 19, + 62, + 27, + 7, + 34, + 15, + 42, + 35, + 6, + 43, + 14, + 18, + 55, + 26, + 63 + ], + "index": 35 + }, + { + "X_character_permutation": [ + 0, + 1, + 32, + 33, + 4, + 5, + 36, + 37, + 8, + 9, + 40, + 41, + 12, + 13, + 44, + 45, + 16, + 17, + 48, + 49, + 20, + 21, + 52, + 53, + 24, + 25, + 56, + 57, + 28, + 29, + 60, + 61, + 2, + 3, + 34, + 35, + 6, + 7, + 38, + 39, + 10, + 11, + 42, + 43, + 14, + 15, + 46, + 47, + 18, + 19, + 50, + 51, + 22, + 23, + 54, + 55, + 26, + 27, + 58, + 59, + 30, + 31, + 62, + 63 + ], + "index": 36 + }, + { + "X_character_permutation": [ + 0, + 22, + 32, + 54, + 19, + 5, + 51, + 37, + 21, + 3, + 53, + 35, + 6, + 16, + 38, + 48, + 7, + 17, + 39, + 49, + 20, + 2, + 52, + 34, + 18, + 4, + 50, + 36, + 1, + 23, + 33, + 55, + 8, + 30, + 40, + 62, + 27, + 13, + 59, + 45, + 29, + 11, + 61, + 43, + 14, + 24, + 46, + 56, + 15, + 25, + 47, + 57, + 28, + 10, + 60, + 42, + 26, + 12, + 58, + 44, + 9, + 31, + 41, + 63 + ], + "index": 37 + }, + { + "X_character_permutation": [ + 0, + 25, + 32, + 57, + 28, + 5, + 60, + 37, + 2, + 27, + 34, + 59, + 30, + 7, + 62, + 39, + 13, + 20, + 45, + 52, + 17, + 8, + 49, + 40, + 15, + 22, + 47, + 54, + 19, + 10, + 51, + 42, + 21, + 12, + 53, + 44, + 9, + 16, + 41, + 48, + 23, + 14, + 55, + 46, + 11, + 18, + 43, + 50, + 24, + 1, + 56, + 33, + 4, + 29, + 36, + 61, + 26, + 3, + 58, + 35, + 6, + 31, + 38, + 63 + ], + "index": 38 + }, + { + "X_character_permutation": [ + 0, + 37, + 2, + 39, + 49, + 20, + 51, + 22, + 8, + 45, + 10, + 47, + 57, + 28, + 59, + 30, + 52, + 17, + 54, + 19, + 5, + 32, + 7, + 34, + 60, + 25, + 62, + 27, + 13, + 40, + 15, + 42, + 21, + 48, + 23, + 50, + 36, + 1, + 38, + 3, + 29, + 56, + 31, + 58, + 44, + 9, + 46, + 11, + 33, + 4, + 35, + 6, + 16, + 53, + 18, + 55, + 41, + 12, + 43, + 14, + 24, + 61, + 26, + 63 + ], + "index": 39 + }, + { + "X_character_permutation": [ + 0, + 25, + 21, + 12, + 13, + 20, + 24, + 1, + 32, + 57, + 53, + 44, + 45, + 52, + 56, + 33, + 28, + 5, + 9, + 16, + 17, + 8, + 4, + 29, + 60, + 37, + 41, + 48, + 49, + 40, + 36, + 61, + 2, + 27, + 23, + 14, + 15, + 22, + 26, + 3, + 34, + 59, + 55, + 46, + 47, + 54, + 58, + 35, + 30, + 7, + 11, + 18, + 19, + 10, + 6, + 31, + 62, + 39, + 43, + 50, + 51, + 42, + 38, + 63 + ], + "index": 40 + }, + { + "X_character_permutation": [ + 0, + 37, + 21, + 48, + 52, + 17, + 33, + 4, + 2, + 39, + 23, + 50, + 54, + 19, + 35, + 6, + 49, + 20, + 36, + 1, + 5, + 32, + 16, + 53, + 51, + 22, + 38, + 3, + 7, + 34, + 18, + 55, + 8, + 45, + 29, + 56, + 60, + 25, + 41, + 12, + 10, + 47, + 31, + 58, + 62, + 27, + 43, + 14, + 57, + 28, + 44, + 9, + 13, + 40, + 24, + 61, + 59, + 30, + 46, + 11, + 15, + 42, + 26, + 63 + ], + "index": 41 + }, + { + "X_character_permutation": [ + 0, + 28, + 32, + 60, + 25, + 5, + 57, + 37, + 2, + 30, + 34, + 62, + 27, + 7, + 59, + 39, + 13, + 17, + 45, + 49, + 20, + 8, + 52, + 40, + 15, + 19, + 47, + 51, + 22, + 10, + 54, + 42, + 21, + 9, + 53, + 41, + 12, + 16, + 44, + 48, + 23, + 11, + 55, + 43, + 14, + 18, + 46, + 50, + 24, + 4, + 56, + 36, + 1, + 29, + 33, + 61, + 26, + 6, + 58, + 38, + 3, + 31, + 35, + 63 + ], + "index": 42 + }, + { + "X_character_permutation": [ + 0, + 19, + 21, + 6, + 22, + 5, + 3, + 16, + 8, + 27, + 29, + 14, + 30, + 13, + 11, + 24, + 7, + 20, + 18, + 1, + 17, + 2, + 4, + 23, + 15, + 28, + 26, + 9, + 25, + 10, + 12, + 31, + 32, + 51, + 53, + 38, + 54, + 37, + 35, + 48, + 40, + 59, + 61, + 46, + 62, + 45, + 43, + 56, + 39, + 52, + 50, + 33, + 49, + 34, + 36, + 55, + 47, + 60, + 58, + 41, + 57, + 42, + 44, + 63 + ], + "index": 43 + }, + { + "X_character_permutation": [ + 0, + 13, + 21, + 24, + 25, + 20, + 12, + 1, + 32, + 45, + 53, + 56, + 57, + 52, + 44, + 33, + 28, + 17, + 9, + 4, + 5, + 8, + 16, + 29, + 60, + 49, + 41, + 36, + 37, + 40, + 48, + 61, + 2, + 15, + 23, + 26, + 27, + 22, + 14, + 3, + 34, + 47, + 55, + 58, + 59, + 54, + 46, + 35, + 30, + 19, + 11, + 6, + 7, + 10, + 18, + 31, + 62, + 51, + 43, + 38, + 39, + 42, + 50, + 63 + ], + "index": 44 + }, + { + "X_character_permutation": [ + 0, + 28, + 21, + 9, + 25, + 5, + 12, + 16, + 32, + 60, + 53, + 41, + 57, + 37, + 44, + 48, + 13, + 17, + 24, + 4, + 20, + 8, + 1, + 29, + 45, + 49, + 56, + 36, + 52, + 40, + 33, + 61, + 2, + 30, + 23, + 11, + 27, + 7, + 14, + 18, + 34, + 62, + 55, + 43, + 59, + 39, + 46, + 50, + 15, + 19, + 26, + 6, + 22, + 10, + 3, + 31, + 47, + 51, + 58, + 38, + 54, + 42, + 35, + 63 + ], + "index": 45 + }, + { + "X_character_permutation": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "index": 46 + }, + { + "X_character_permutation": [ + 0, + 19, + 8, + 27, + 22, + 5, + 30, + 13, + 32, + 51, + 40, + 59, + 54, + 37, + 62, + 45, + 7, + 20, + 15, + 28, + 17, + 2, + 25, + 10, + 39, + 52, + 47, + 60, + 49, + 34, + 57, + 42, + 21, + 6, + 29, + 14, + 3, + 16, + 11, + 24, + 53, + 38, + 61, + 46, + 35, + 48, + 43, + 56, + 18, + 1, + 26, + 9, + 4, + 23, + 12, + 31, + 50, + 33, + 58, + 41, + 36, + 55, + 44, + 63 + ], + "index": 47 + }, + { + "X_character_permutation": [ + 0, + 13, + 32, + 45, + 25, + 20, + 57, + 52, + 2, + 15, + 34, + 47, + 27, + 22, + 59, + 54, + 28, + 17, + 60, + 49, + 5, + 8, + 37, + 40, + 30, + 19, + 62, + 51, + 7, + 10, + 39, + 42, + 21, + 24, + 53, + 56, + 12, + 1, + 44, + 33, + 23, + 26, + 55, + 58, + 14, + 3, + 46, + 35, + 9, + 4, + 41, + 36, + 16, + 29, + 48, + 61, + 11, + 6, + 43, + 38, + 18, + 31, + 50, + 63 + ], + "index": 48 + }, + { + "X_character_permutation": [ + 0, + 49, + 8, + 57, + 37, + 20, + 45, + 28, + 21, + 36, + 29, + 44, + 48, + 1, + 56, + 9, + 52, + 5, + 60, + 13, + 17, + 32, + 25, + 40, + 33, + 16, + 41, + 24, + 4, + 53, + 12, + 61, + 2, + 51, + 10, + 59, + 39, + 22, + 47, + 30, + 23, + 38, + 31, + 46, + 50, + 3, + 58, + 11, + 54, + 7, + 62, + 15, + 19, + 34, + 27, + 42, + 35, + 18, + 43, + 26, + 6, + 55, + 14, + 63 + ], + "index": 49 + }, + { + "X_character_permutation": [ + 0, + 7, + 32, + 39, + 22, + 17, + 54, + 49, + 21, + 18, + 53, + 50, + 3, + 4, + 35, + 36, + 19, + 20, + 51, + 52, + 5, + 2, + 37, + 34, + 6, + 1, + 38, + 33, + 16, + 23, + 48, + 55, + 8, + 15, + 40, + 47, + 30, + 25, + 62, + 57, + 29, + 26, + 61, + 58, + 11, + 12, + 43, + 44, + 27, + 28, + 59, + 60, + 13, + 10, + 45, + 42, + 14, + 9, + 46, + 41, + 24, + 31, + 56, + 63 + ], + "index": 50 + }, + { + "X_character_permutation": [ + 0, + 52, + 8, + 60, + 49, + 5, + 57, + 13, + 21, + 33, + 29, + 41, + 36, + 16, + 44, + 24, + 37, + 17, + 45, + 25, + 20, + 32, + 28, + 40, + 48, + 4, + 56, + 12, + 1, + 53, + 9, + 61, + 2, + 54, + 10, + 62, + 51, + 7, + 59, + 15, + 23, + 35, + 31, + 43, + 38, + 18, + 46, + 26, + 39, + 19, + 47, + 27, + 22, + 34, + 30, + 42, + 50, + 6, + 58, + 14, + 3, + 55, + 11, + 63 + ], + "index": 51 + }, + { + "X_character_permutation": [ + 0, + 49, + 21, + 36, + 52, + 5, + 33, + 16, + 2, + 51, + 23, + 38, + 54, + 7, + 35, + 18, + 37, + 20, + 48, + 1, + 17, + 32, + 4, + 53, + 39, + 22, + 50, + 3, + 19, + 34, + 6, + 55, + 8, + 57, + 29, + 44, + 60, + 13, + 41, + 24, + 10, + 59, + 31, + 46, + 62, + 15, + 43, + 26, + 45, + 28, + 56, + 9, + 25, + 40, + 12, + 61, + 47, + 30, + 58, + 11, + 27, + 42, + 14, + 63 + ], + "index": 52 + }, + { + "X_character_permutation": [ + 0, + 7, + 21, + 18, + 19, + 20, + 6, + 1, + 8, + 15, + 29, + 26, + 27, + 28, + 14, + 9, + 22, + 17, + 3, + 4, + 5, + 2, + 16, + 23, + 30, + 25, + 11, + 12, + 13, + 10, + 24, + 31, + 32, + 39, + 53, + 50, + 51, + 52, + 38, + 33, + 40, + 47, + 61, + 58, + 59, + 60, + 46, + 41, + 54, + 49, + 35, + 36, + 37, + 34, + 48, + 55, + 62, + 57, + 43, + 44, + 45, + 42, + 56, + 63 + ], + "index": 53 + }, + { + "X_character_permutation": [ + 0, + 52, + 21, + 33, + 49, + 5, + 36, + 16, + 2, + 54, + 23, + 35, + 51, + 7, + 38, + 18, + 37, + 17, + 48, + 4, + 20, + 32, + 1, + 53, + 39, + 19, + 50, + 6, + 22, + 34, + 3, + 55, + 8, + 60, + 29, + 41, + 57, + 13, + 44, + 24, + 10, + 62, + 31, + 43, + 59, + 15, + 46, + 26, + 45, + 25, + 56, + 12, + 28, + 40, + 9, + 61, + 47, + 27, + 58, + 14, + 30, + 42, + 11, + 63 + ], + "index": 54 + }, + { + "X_character_permutation": [ + 0, + 49, + 8, + 57, + 52, + 5, + 60, + 13, + 21, + 36, + 29, + 44, + 33, + 16, + 41, + 24, + 37, + 20, + 45, + 28, + 17, + 32, + 25, + 40, + 48, + 1, + 56, + 9, + 4, + 53, + 12, + 61, + 2, + 51, + 10, + 59, + 54, + 7, + 62, + 15, + 23, + 38, + 31, + 46, + 35, + 18, + 43, + 26, + 39, + 22, + 47, + 30, + 19, + 34, + 27, + 42, + 50, + 3, + 58, + 11, + 6, + 55, + 14, + 63 + ], + "index": 55 + }, + { + "X_character_permutation": [ + 0, + 7, + 32, + 39, + 19, + 20, + 51, + 52, + 21, + 18, + 53, + 50, + 6, + 1, + 38, + 33, + 22, + 17, + 54, + 49, + 5, + 2, + 37, + 34, + 3, + 4, + 35, + 36, + 16, + 23, + 48, + 55, + 8, + 15, + 40, + 47, + 27, + 28, + 59, + 60, + 29, + 26, + 61, + 58, + 14, + 9, + 46, + 41, + 30, + 25, + 62, + 57, + 13, + 10, + 45, + 42, + 11, + 12, + 43, + 44, + 24, + 31, + 56, + 63 + ], + "index": 56 + }, + { + "X_character_permutation": [ + 0, + 19, + 8, + 27, + 7, + 20, + 15, + 28, + 32, + 51, + 40, + 59, + 39, + 52, + 47, + 60, + 22, + 5, + 30, + 13, + 17, + 2, + 25, + 10, + 54, + 37, + 62, + 45, + 49, + 34, + 57, + 42, + 21, + 6, + 29, + 14, + 18, + 1, + 26, + 9, + 53, + 38, + 61, + 46, + 50, + 33, + 58, + 41, + 3, + 16, + 11, + 24, + 4, + 23, + 12, + 31, + 35, + 48, + 43, + 56, + 36, + 55, + 44, + 63 + ], + "index": 57 + }, + { + "X_character_permutation": [ + 0, + 13, + 32, + 45, + 28, + 17, + 60, + 49, + 2, + 15, + 34, + 47, + 30, + 19, + 62, + 51, + 25, + 20, + 57, + 52, + 5, + 8, + 37, + 40, + 27, + 22, + 59, + 54, + 7, + 10, + 39, + 42, + 21, + 24, + 53, + 56, + 9, + 4, + 41, + 36, + 23, + 26, + 55, + 58, + 11, + 6, + 43, + 38, + 12, + 1, + 44, + 33, + 16, + 29, + 48, + 61, + 14, + 3, + 46, + 35, + 18, + 31, + 50, + 63 + ], + "index": 58 + }, + { + "X_character_permutation": [ + 0, + 1, + 2, + 3, + 16, + 17, + 18, + 19, + 32, + 33, + 34, + 35, + 48, + 49, + 50, + 51, + 4, + 5, + 6, + 7, + 20, + 21, + 22, + 23, + 36, + 37, + 38, + 39, + 52, + 53, + 54, + 55, + 8, + 9, + 10, + 11, + 24, + 25, + 26, + 27, + 40, + 41, + 42, + 43, + 56, + 57, + 58, + 59, + 12, + 13, + 14, + 15, + 28, + 29, + 30, + 31, + 44, + 45, + 46, + 47, + 60, + 61, + 62, + 63 + ], + "index": 59 + }, + { + "X_character_permutation": [ + 0, + 52, + 8, + 60, + 49, + 5, + 57, + 13, + 2, + 54, + 10, + 62, + 51, + 7, + 59, + 15, + 37, + 17, + 45, + 25, + 20, + 32, + 28, + 40, + 39, + 19, + 47, + 27, + 22, + 34, + 30, + 42, + 21, + 33, + 29, + 41, + 36, + 16, + 44, + 24, + 23, + 35, + 31, + 43, + 38, + 18, + 46, + 26, + 48, + 4, + 56, + 12, + 1, + 53, + 9, + 61, + 50, + 6, + 58, + 14, + 3, + 55, + 11, + 63 + ], + "index": 60 + }, + { + "X_character_permutation": [ + 0, + 4, + 2, + 6, + 1, + 5, + 3, + 7, + 8, + 12, + 10, + 14, + 9, + 13, + 11, + 15, + 16, + 20, + 18, + 22, + 17, + 21, + 19, + 23, + 24, + 28, + 26, + 30, + 25, + 29, + 27, + 31, + 32, + 36, + 34, + 38, + 33, + 37, + 35, + 39, + 40, + 44, + 42, + 46, + 41, + 45, + 43, + 47, + 48, + 52, + 50, + 54, + 49, + 53, + 51, + 55, + 56, + 60, + 58, + 62, + 57, + 61, + 59, + 63 + ], + "index": 61 + }, + { + "X_character_permutation": [ + 0, + 16, + 8, + 24, + 4, + 20, + 12, + 28, + 32, + 48, + 40, + 56, + 36, + 52, + 44, + 60, + 1, + 17, + 9, + 25, + 5, + 21, + 13, + 29, + 33, + 49, + 41, + 57, + 37, + 53, + 45, + 61, + 2, + 18, + 10, + 26, + 6, + 22, + 14, + 30, + 34, + 50, + 42, + 58, + 38, + 54, + 46, + 62, + 3, + 19, + 11, + 27, + 7, + 23, + 15, + 31, + 35, + 51, + 43, + 59, + 39, + 55, + 47, + 63 + ], + "index": 62 + }, + { + "X_character_permutation": [ + 0, + 1, + 8, + 9, + 4, + 5, + 12, + 13, + 32, + 33, + 40, + 41, + 36, + 37, + 44, + 45, + 16, + 17, + 24, + 25, + 20, + 21, + 28, + 29, + 48, + 49, + 56, + 57, + 52, + 53, + 60, + 61, + 2, + 3, + 10, + 11, + 6, + 7, + 14, + 15, + 34, + 35, + 42, + 43, + 38, + 39, + 46, + 47, + 18, + 19, + 26, + 27, + 22, + 23, + 30, + 31, + 50, + 51, + 58, + 59, + 54, + 55, + 62, + 63 + ], + "index": 63 + }, + { + "X_character_permutation": [ + 0, + 22, + 21, + 3, + 19, + 5, + 6, + 16, + 32, + 54, + 53, + 35, + 51, + 37, + 38, + 48, + 7, + 17, + 18, + 4, + 20, + 2, + 1, + 23, + 39, + 49, + 50, + 36, + 52, + 34, + 33, + 55, + 8, + 30, + 29, + 11, + 27, + 13, + 14, + 24, + 40, + 62, + 61, + 43, + 59, + 45, + 46, + 56, + 15, + 25, + 26, + 12, + 28, + 10, + 9, + 31, + 47, + 57, + 58, + 44, + 60, + 42, + 41, + 63 + ], + "index": 64 + }, + { + "X_character_permutation": [ + 0, + 25, + 2, + 27, + 28, + 5, + 30, + 7, + 32, + 57, + 34, + 59, + 60, + 37, + 62, + 39, + 13, + 20, + 15, + 22, + 17, + 8, + 19, + 10, + 45, + 52, + 47, + 54, + 49, + 40, + 51, + 42, + 21, + 12, + 23, + 14, + 9, + 16, + 11, + 18, + 53, + 44, + 55, + 46, + 41, + 48, + 43, + 50, + 24, + 1, + 26, + 3, + 4, + 29, + 6, + 31, + 56, + 33, + 58, + 35, + 36, + 61, + 38, + 63 + ], + "index": 65 + }, + { + "X_character_permutation": [ + 0, + 37, + 8, + 45, + 49, + 20, + 57, + 28, + 2, + 39, + 10, + 47, + 51, + 22, + 59, + 30, + 52, + 17, + 60, + 25, + 5, + 32, + 13, + 40, + 54, + 19, + 62, + 27, + 7, + 34, + 15, + 42, + 21, + 48, + 29, + 56, + 36, + 1, + 44, + 9, + 23, + 50, + 31, + 58, + 38, + 3, + 46, + 11, + 33, + 4, + 41, + 12, + 16, + 53, + 24, + 61, + 35, + 6, + 43, + 14, + 18, + 55, + 26, + 63 + ], + "index": 66 + }, + { + "X_character_permutation": [ + 0, + 25, + 32, + 57, + 13, + 20, + 45, + 52, + 21, + 12, + 53, + 44, + 24, + 1, + 56, + 33, + 28, + 5, + 60, + 37, + 17, + 8, + 49, + 40, + 9, + 16, + 41, + 48, + 4, + 29, + 36, + 61, + 2, + 27, + 34, + 59, + 15, + 22, + 47, + 54, + 23, + 14, + 55, + 46, + 26, + 3, + 58, + 35, + 30, + 7, + 62, + 39, + 19, + 10, + 51, + 42, + 11, + 18, + 43, + 50, + 6, + 31, + 38, + 63 + ], + "index": 67 + }, + { + "X_character_permutation": [ + 0, + 37, + 2, + 39, + 52, + 17, + 54, + 19, + 21, + 48, + 23, + 50, + 33, + 4, + 35, + 6, + 49, + 20, + 51, + 22, + 5, + 32, + 7, + 34, + 36, + 1, + 38, + 3, + 16, + 53, + 18, + 55, + 8, + 45, + 10, + 47, + 60, + 25, + 62, + 27, + 29, + 56, + 31, + 58, + 41, + 12, + 43, + 14, + 57, + 28, + 59, + 30, + 13, + 40, + 15, + 42, + 44, + 9, + 46, + 11, + 24, + 61, + 26, + 63 + ], + "index": 68 + }, + { + "X_character_permutation": [ + 0, + 28, + 32, + 60, + 25, + 5, + 57, + 37, + 21, + 9, + 53, + 41, + 12, + 16, + 44, + 48, + 13, + 17, + 45, + 49, + 20, + 8, + 52, + 40, + 24, + 4, + 56, + 36, + 1, + 29, + 33, + 61, + 2, + 30, + 34, + 62, + 27, + 7, + 59, + 39, + 23, + 11, + 55, + 43, + 14, + 18, + 46, + 50, + 15, + 19, + 47, + 51, + 22, + 10, + 54, + 42, + 26, + 6, + 58, + 38, + 3, + 31, + 35, + 63 + ], + "index": 69 + }, + { + "X_character_permutation": [ + 0, + 4, + 32, + 36, + 1, + 5, + 33, + 37, + 2, + 6, + 34, + 38, + 3, + 7, + 35, + 39, + 16, + 20, + 48, + 52, + 17, + 21, + 49, + 53, + 18, + 22, + 50, + 54, + 19, + 23, + 51, + 55, + 8, + 12, + 40, + 44, + 9, + 13, + 41, + 45, + 10, + 14, + 42, + 46, + 11, + 15, + 43, + 47, + 24, + 28, + 56, + 60, + 25, + 29, + 57, + 61, + 26, + 30, + 58, + 62, + 27, + 31, + 59, + 63 + ], + "index": 70 + }, + { + "X_character_permutation": [ + 0, + 16, + 2, + 18, + 4, + 20, + 6, + 22, + 8, + 24, + 10, + 26, + 12, + 28, + 14, + 30, + 1, + 17, + 3, + 19, + 5, + 21, + 7, + 23, + 9, + 25, + 11, + 27, + 13, + 29, + 15, + 31, + 32, + 48, + 34, + 50, + 36, + 52, + 38, + 54, + 40, + 56, + 42, + 58, + 44, + 60, + 46, + 62, + 33, + 49, + 35, + 51, + 37, + 53, + 39, + 55, + 41, + 57, + 43, + 59, + 45, + 61, + 47, + 63 + ], + "index": 71 + }, + { + "X_character_permutation": [ + 0, + 1, + 32, + 33, + 4, + 5, + 36, + 37, + 2, + 3, + 34, + 35, + 6, + 7, + 38, + 39, + 16, + 17, + 48, + 49, + 20, + 21, + 52, + 53, + 18, + 19, + 50, + 51, + 22, + 23, + 54, + 55, + 8, + 9, + 40, + 41, + 12, + 13, + 44, + 45, + 10, + 11, + 42, + 43, + 14, + 15, + 46, + 47, + 24, + 25, + 56, + 57, + 28, + 29, + 60, + 61, + 26, + 27, + 58, + 59, + 30, + 31, + 62, + 63 + ], + "index": 72 + }, + { + "X_character_permutation": [ + 0, + 25, + 32, + 57, + 28, + 5, + 60, + 37, + 21, + 12, + 53, + 44, + 9, + 16, + 41, + 48, + 13, + 20, + 45, + 52, + 17, + 8, + 49, + 40, + 24, + 1, + 56, + 33, + 4, + 29, + 36, + 61, + 2, + 27, + 34, + 59, + 30, + 7, + 62, + 39, + 23, + 14, + 55, + 46, + 11, + 18, + 43, + 50, + 15, + 22, + 47, + 54, + 19, + 10, + 51, + 42, + 26, + 3, + 58, + 35, + 6, + 31, + 38, + 63 + ], + "index": 73 + }, + { + "X_character_permutation": [ + 0, + 37, + 2, + 39, + 49, + 20, + 51, + 22, + 21, + 48, + 23, + 50, + 36, + 1, + 38, + 3, + 52, + 17, + 54, + 19, + 5, + 32, + 7, + 34, + 33, + 4, + 35, + 6, + 16, + 53, + 18, + 55, + 8, + 45, + 10, + 47, + 57, + 28, + 59, + 30, + 29, + 56, + 31, + 58, + 44, + 9, + 46, + 11, + 60, + 25, + 62, + 27, + 13, + 40, + 15, + 42, + 41, + 12, + 43, + 14, + 24, + 61, + 26, + 63 + ], + "index": 74 + }, + { + "X_character_permutation": [ + 0, + 25, + 2, + 27, + 13, + 20, + 15, + 22, + 32, + 57, + 34, + 59, + 45, + 52, + 47, + 54, + 28, + 5, + 30, + 7, + 17, + 8, + 19, + 10, + 60, + 37, + 62, + 39, + 49, + 40, + 51, + 42, + 21, + 12, + 23, + 14, + 24, + 1, + 26, + 3, + 53, + 44, + 55, + 46, + 56, + 33, + 58, + 35, + 9, + 16, + 11, + 18, + 4, + 29, + 6, + 31, + 41, + 48, + 43, + 50, + 36, + 61, + 38, + 63 + ], + "index": 75 + }, + { + "X_character_permutation": [ + 0, + 37, + 8, + 45, + 52, + 17, + 60, + 25, + 2, + 39, + 10, + 47, + 54, + 19, + 62, + 27, + 49, + 20, + 57, + 28, + 5, + 32, + 13, + 40, + 51, + 22, + 59, + 30, + 7, + 34, + 15, + 42, + 21, + 48, + 29, + 56, + 33, + 4, + 41, + 12, + 23, + 50, + 31, + 58, + 35, + 6, + 43, + 14, + 36, + 1, + 44, + 9, + 16, + 53, + 24, + 61, + 38, + 3, + 46, + 11, + 18, + 55, + 26, + 63 + ], + "index": 76 + }, + { + "X_character_permutation": [ + 0, + 22, + 21, + 3, + 7, + 17, + 18, + 4, + 32, + 54, + 53, + 35, + 39, + 49, + 50, + 36, + 19, + 5, + 6, + 16, + 20, + 2, + 1, + 23, + 51, + 37, + 38, + 48, + 52, + 34, + 33, + 55, + 8, + 30, + 29, + 11, + 15, + 25, + 26, + 12, + 40, + 62, + 61, + 43, + 47, + 57, + 58, + 44, + 27, + 13, + 14, + 24, + 28, + 10, + 9, + 31, + 59, + 45, + 46, + 56, + 60, + 42, + 41, + 63 + ], + "index": 77 + }, + { + "X_character_permutation": [ + 0, + 19, + 32, + 51, + 22, + 5, + 54, + 37, + 8, + 27, + 40, + 59, + 30, + 13, + 62, + 45, + 7, + 20, + 39, + 52, + 17, + 2, + 49, + 34, + 15, + 28, + 47, + 60, + 25, + 10, + 57, + 42, + 21, + 6, + 53, + 38, + 3, + 16, + 35, + 48, + 29, + 14, + 61, + 46, + 11, + 24, + 43, + 56, + 18, + 1, + 50, + 33, + 4, + 23, + 36, + 55, + 26, + 9, + 58, + 41, + 12, + 31, + 44, + 63 + ], + "index": 78 + }, + { + "X_character_permutation": [ + 0, + 13, + 2, + 15, + 25, + 20, + 27, + 22, + 32, + 45, + 34, + 47, + 57, + 52, + 59, + 54, + 28, + 17, + 30, + 19, + 5, + 8, + 7, + 10, + 60, + 49, + 62, + 51, + 37, + 40, + 39, + 42, + 21, + 24, + 23, + 26, + 12, + 1, + 14, + 3, + 53, + 56, + 55, + 58, + 44, + 33, + 46, + 35, + 9, + 4, + 11, + 6, + 16, + 29, + 18, + 31, + 41, + 36, + 43, + 38, + 48, + 61, + 50, + 63 + ], + "index": 79 + }, + { + "X_character_permutation": [ + 0, + 49, + 21, + 36, + 37, + 20, + 48, + 1, + 8, + 57, + 29, + 44, + 45, + 28, + 56, + 9, + 52, + 5, + 33, + 16, + 17, + 32, + 4, + 53, + 60, + 13, + 41, + 24, + 25, + 40, + 12, + 61, + 2, + 51, + 23, + 38, + 39, + 22, + 50, + 3, + 10, + 59, + 31, + 46, + 47, + 30, + 58, + 11, + 54, + 7, + 35, + 18, + 19, + 34, + 6, + 55, + 62, + 15, + 43, + 26, + 27, + 42, + 14, + 63 + ], + "index": 80 + }, + { + "X_character_permutation": [ + 0, + 7, + 21, + 18, + 22, + 17, + 3, + 4, + 32, + 39, + 53, + 50, + 54, + 49, + 35, + 36, + 19, + 20, + 6, + 1, + 5, + 2, + 16, + 23, + 51, + 52, + 38, + 33, + 37, + 34, + 48, + 55, + 8, + 15, + 29, + 26, + 30, + 25, + 11, + 12, + 40, + 47, + 61, + 58, + 62, + 57, + 43, + 44, + 27, + 28, + 14, + 9, + 13, + 10, + 24, + 31, + 59, + 60, + 46, + 41, + 45, + 42, + 56, + 63 + ], + "index": 81 + }, + { + "X_character_permutation": [ + 0, + 19, + 21, + 6, + 22, + 5, + 3, + 16, + 32, + 51, + 53, + 38, + 54, + 37, + 35, + 48, + 7, + 20, + 18, + 1, + 17, + 2, + 4, + 23, + 39, + 52, + 50, + 33, + 49, + 34, + 36, + 55, + 8, + 27, + 29, + 14, + 30, + 13, + 11, + 24, + 40, + 59, + 61, + 46, + 62, + 45, + 43, + 56, + 15, + 28, + 26, + 9, + 25, + 10, + 12, + 31, + 47, + 60, + 58, + 41, + 57, + 42, + 44, + 63 + ], + "index": 82 + }, + { + "X_character_permutation": [ + 0, + 13, + 21, + 24, + 25, + 20, + 12, + 1, + 2, + 15, + 23, + 26, + 27, + 22, + 14, + 3, + 28, + 17, + 9, + 4, + 5, + 8, + 16, + 29, + 30, + 19, + 11, + 6, + 7, + 10, + 18, + 31, + 32, + 45, + 53, + 56, + 57, + 52, + 44, + 33, + 34, + 47, + 55, + 58, + 59, + 54, + 46, + 35, + 60, + 49, + 41, + 36, + 37, + 40, + 48, + 61, + 62, + 51, + 43, + 38, + 39, + 42, + 50, + 63 + ], + "index": 83 + }, + { + "X_character_permutation": [ + 0, + 4, + 8, + 12, + 1, + 5, + 9, + 13, + 32, + 36, + 40, + 44, + 33, + 37, + 41, + 45, + 16, + 20, + 24, + 28, + 17, + 21, + 25, + 29, + 48, + 52, + 56, + 60, + 49, + 53, + 57, + 61, + 2, + 6, + 10, + 14, + 3, + 7, + 11, + 15, + 34, + 38, + 42, + 46, + 35, + 39, + 43, + 47, + 18, + 22, + 26, + 30, + 19, + 23, + 27, + 31, + 50, + 54, + 58, + 62, + 51, + 55, + 59, + 63 + ], + "index": 84 + }, + { + "X_character_permutation": [ + 0, + 16, + 32, + 48, + 4, + 20, + 36, + 52, + 2, + 18, + 34, + 50, + 6, + 22, + 38, + 54, + 1, + 17, + 33, + 49, + 5, + 21, + 37, + 53, + 3, + 19, + 35, + 51, + 7, + 23, + 39, + 55, + 8, + 24, + 40, + 56, + 12, + 28, + 44, + 60, + 10, + 26, + 42, + 58, + 14, + 30, + 46, + 62, + 9, + 25, + 41, + 57, + 13, + 29, + 45, + 61, + 11, + 27, + 43, + 59, + 15, + 31, + 47, + 63 + ], + "index": 85 + }, + { + "X_character_permutation": [ + 0, + 49, + 8, + 57, + 37, + 20, + 45, + 28, + 2, + 51, + 10, + 59, + 39, + 22, + 47, + 30, + 52, + 5, + 60, + 13, + 17, + 32, + 25, + 40, + 54, + 7, + 62, + 15, + 19, + 34, + 27, + 42, + 21, + 36, + 29, + 44, + 48, + 1, + 56, + 9, + 23, + 38, + 31, + 46, + 50, + 3, + 58, + 11, + 33, + 16, + 41, + 24, + 4, + 53, + 12, + 61, + 35, + 18, + 43, + 26, + 6, + 55, + 14, + 63 + ], + "index": 86 + }, + { + "X_character_permutation": [ + 0, + 7, + 32, + 39, + 22, + 17, + 54, + 49, + 8, + 15, + 40, + 47, + 30, + 25, + 62, + 57, + 19, + 20, + 51, + 52, + 5, + 2, + 37, + 34, + 27, + 28, + 59, + 60, + 13, + 10, + 45, + 42, + 21, + 18, + 53, + 50, + 3, + 4, + 35, + 36, + 29, + 26, + 61, + 58, + 11, + 12, + 43, + 44, + 6, + 1, + 38, + 33, + 16, + 23, + 48, + 55, + 14, + 9, + 46, + 41, + 24, + 31, + 56, + 63 + ], + "index": 87 + }, + { + "X_character_permutation": [ + 0, + 52, + 2, + 54, + 37, + 17, + 39, + 19, + 21, + 33, + 23, + 35, + 48, + 4, + 50, + 6, + 49, + 5, + 51, + 7, + 20, + 32, + 22, + 34, + 36, + 16, + 38, + 18, + 1, + 53, + 3, + 55, + 8, + 60, + 10, + 62, + 45, + 25, + 47, + 27, + 29, + 41, + 31, + 43, + 56, + 12, + 58, + 14, + 57, + 13, + 59, + 15, + 28, + 40, + 30, + 42, + 44, + 24, + 46, + 26, + 9, + 61, + 11, + 63 + ], + "index": 88 + }, + { + "X_character_permutation": [ + 0, + 49, + 2, + 51, + 52, + 5, + 54, + 7, + 21, + 36, + 23, + 38, + 33, + 16, + 35, + 18, + 37, + 20, + 39, + 22, + 17, + 32, + 19, + 34, + 48, + 1, + 50, + 3, + 4, + 53, + 6, + 55, + 8, + 57, + 10, + 59, + 60, + 13, + 62, + 15, + 29, + 44, + 31, + 46, + 41, + 24, + 43, + 26, + 45, + 28, + 47, + 30, + 25, + 40, + 27, + 42, + 56, + 9, + 58, + 11, + 12, + 61, + 14, + 63 + ], + "index": 89 + }, + { + "X_character_permutation": [ + 0, + 7, + 8, + 15, + 19, + 20, + 27, + 28, + 21, + 18, + 29, + 26, + 6, + 1, + 14, + 9, + 22, + 17, + 30, + 25, + 5, + 2, + 13, + 10, + 3, + 4, + 11, + 12, + 16, + 23, + 24, + 31, + 32, + 39, + 40, + 47, + 51, + 52, + 59, + 60, + 53, + 50, + 61, + 58, + 38, + 33, + 46, + 41, + 54, + 49, + 62, + 57, + 37, + 34, + 45, + 42, + 35, + 36, + 43, + 44, + 48, + 55, + 56, + 63 + ], + "index": 90 + }, + { + "X_character_permutation": [ + 0, + 19, + 21, + 6, + 7, + 20, + 18, + 1, + 32, + 51, + 53, + 38, + 39, + 52, + 50, + 33, + 22, + 5, + 3, + 16, + 17, + 2, + 4, + 23, + 54, + 37, + 35, + 48, + 49, + 34, + 36, + 55, + 8, + 27, + 29, + 14, + 15, + 28, + 26, + 9, + 40, + 59, + 61, + 46, + 47, + 60, + 58, + 41, + 30, + 13, + 11, + 24, + 25, + 10, + 12, + 31, + 62, + 45, + 43, + 56, + 57, + 42, + 44, + 63 + ], + "index": 91 + }, + { + "X_character_permutation": [ + 0, + 13, + 21, + 24, + 28, + 17, + 9, + 4, + 2, + 15, + 23, + 26, + 30, + 19, + 11, + 6, + 25, + 20, + 12, + 1, + 5, + 8, + 16, + 29, + 27, + 22, + 14, + 3, + 7, + 10, + 18, + 31, + 32, + 45, + 53, + 56, + 60, + 49, + 41, + 36, + 34, + 47, + 55, + 58, + 62, + 51, + 43, + 38, + 57, + 52, + 44, + 33, + 37, + 40, + 48, + 61, + 59, + 54, + 46, + 35, + 39, + 42, + 50, + 63 + ], + "index": 92 + }, + { + "X_character_permutation": [ + 0, + 49, + 21, + 36, + 52, + 5, + 33, + 16, + 8, + 57, + 29, + 44, + 60, + 13, + 41, + 24, + 37, + 20, + 48, + 1, + 17, + 32, + 4, + 53, + 45, + 28, + 56, + 9, + 25, + 40, + 12, + 61, + 2, + 51, + 23, + 38, + 54, + 7, + 35, + 18, + 10, + 59, + 31, + 46, + 62, + 15, + 43, + 26, + 39, + 22, + 50, + 3, + 19, + 34, + 6, + 55, + 47, + 30, + 58, + 11, + 27, + 42, + 14, + 63 + ], + "index": 93 + }, + { + "X_character_permutation": [ + 0, + 7, + 21, + 18, + 19, + 20, + 6, + 1, + 32, + 39, + 53, + 50, + 51, + 52, + 38, + 33, + 22, + 17, + 3, + 4, + 5, + 2, + 16, + 23, + 54, + 49, + 35, + 36, + 37, + 34, + 48, + 55, + 8, + 15, + 29, + 26, + 27, + 28, + 14, + 9, + 40, + 47, + 61, + 58, + 59, + 60, + 46, + 41, + 30, + 25, + 11, + 12, + 13, + 10, + 24, + 31, + 62, + 57, + 43, + 44, + 45, + 42, + 56, + 63 + ], + "index": 94 + }, + { + "X_character_permutation": [ + 0, + 19, + 8, + 27, + 7, + 20, + 15, + 28, + 21, + 6, + 29, + 14, + 18, + 1, + 26, + 9, + 22, + 5, + 30, + 13, + 17, + 2, + 25, + 10, + 3, + 16, + 11, + 24, + 4, + 23, + 12, + 31, + 32, + 51, + 40, + 59, + 39, + 52, + 47, + 60, + 53, + 38, + 61, + 46, + 50, + 33, + 58, + 41, + 54, + 37, + 62, + 45, + 49, + 34, + 57, + 42, + 35, + 48, + 43, + 56, + 36, + 55, + 44, + 63 + ], + "index": 95 + }, + { + "X_character_permutation": [ + 0, + 13, + 32, + 45, + 28, + 17, + 60, + 49, + 21, + 24, + 53, + 56, + 9, + 4, + 41, + 36, + 25, + 20, + 57, + 52, + 5, + 8, + 37, + 40, + 12, + 1, + 44, + 33, + 16, + 29, + 48, + 61, + 2, + 15, + 34, + 47, + 30, + 19, + 62, + 51, + 23, + 26, + 55, + 58, + 11, + 6, + 43, + 38, + 27, + 22, + 59, + 54, + 7, + 10, + 39, + 42, + 14, + 3, + 46, + 35, + 18, + 31, + 50, + 63 + ], + "index": 96 + }, + { + "X_character_permutation": [ + 0, + 28, + 2, + 30, + 13, + 17, + 15, + 19, + 32, + 60, + 34, + 62, + 45, + 49, + 47, + 51, + 25, + 5, + 27, + 7, + 20, + 8, + 22, + 10, + 57, + 37, + 59, + 39, + 52, + 40, + 54, + 42, + 21, + 9, + 23, + 11, + 24, + 4, + 26, + 6, + 53, + 41, + 55, + 43, + 56, + 36, + 58, + 38, + 12, + 16, + 14, + 18, + 1, + 29, + 3, + 31, + 44, + 48, + 46, + 50, + 33, + 61, + 35, + 63 + ], + "index": 97 + }, + { + "X_character_permutation": [ + 0, + 49, + 2, + 51, + 52, + 5, + 54, + 7, + 8, + 57, + 10, + 59, + 60, + 13, + 62, + 15, + 37, + 20, + 39, + 22, + 17, + 32, + 19, + 34, + 45, + 28, + 47, + 30, + 25, + 40, + 27, + 42, + 21, + 36, + 23, + 38, + 33, + 16, + 35, + 18, + 29, + 44, + 31, + 46, + 41, + 24, + 43, + 26, + 48, + 1, + 50, + 3, + 4, + 53, + 6, + 55, + 56, + 9, + 58, + 11, + 12, + 61, + 14, + 63 + ], + "index": 98 + }, + { + "X_character_permutation": [ + 0, + 7, + 8, + 15, + 19, + 20, + 27, + 28, + 32, + 39, + 40, + 47, + 51, + 52, + 59, + 60, + 22, + 17, + 30, + 25, + 5, + 2, + 13, + 10, + 54, + 49, + 62, + 57, + 37, + 34, + 45, + 42, + 21, + 18, + 29, + 26, + 6, + 1, + 14, + 9, + 53, + 50, + 61, + 58, + 38, + 33, + 46, + 41, + 3, + 4, + 11, + 12, + 16, + 23, + 24, + 31, + 35, + 36, + 43, + 44, + 48, + 55, + 56, + 63 + ], + "index": 99 + }, + { + "X_character_permutation": [ + 0, + 4, + 32, + 36, + 16, + 20, + 48, + 52, + 8, + 12, + 40, + 44, + 24, + 28, + 56, + 60, + 1, + 5, + 33, + 37, + 17, + 21, + 49, + 53, + 9, + 13, + 41, + 45, + 25, + 29, + 57, + 61, + 2, + 6, + 34, + 38, + 18, + 22, + 50, + 54, + 10, + 14, + 42, + 46, + 26, + 30, + 58, + 62, + 3, + 7, + 35, + 39, + 19, + 23, + 51, + 55, + 11, + 15, + 43, + 47, + 27, + 31, + 59, + 63 + ], + "index": 100 + }, + { + "X_character_permutation": [ + 0, + 16, + 2, + 18, + 1, + 17, + 3, + 19, + 32, + 48, + 34, + 50, + 33, + 49, + 35, + 51, + 4, + 20, + 6, + 22, + 5, + 21, + 7, + 23, + 36, + 52, + 38, + 54, + 37, + 53, + 39, + 55, + 8, + 24, + 10, + 26, + 9, + 25, + 11, + 27, + 40, + 56, + 42, + 58, + 41, + 57, + 43, + 59, + 12, + 28, + 14, + 30, + 13, + 29, + 15, + 31, + 44, + 60, + 46, + 62, + 45, + 61, + 47, + 63 + ], + "index": 101 + }, + { + "X_character_permutation": [ + 0, + 4, + 2, + 6, + 1, + 5, + 3, + 7, + 32, + 36, + 34, + 38, + 33, + 37, + 35, + 39, + 16, + 20, + 18, + 22, + 17, + 21, + 19, + 23, + 48, + 52, + 50, + 54, + 49, + 53, + 51, + 55, + 8, + 12, + 10, + 14, + 9, + 13, + 11, + 15, + 40, + 44, + 42, + 46, + 41, + 45, + 43, + 47, + 24, + 28, + 26, + 30, + 25, + 29, + 27, + 31, + 56, + 60, + 58, + 62, + 57, + 61, + 59, + 63 + ], + "index": 102 + }, + { + "X_character_permutation": [ + 0, + 16, + 8, + 24, + 4, + 20, + 12, + 28, + 2, + 18, + 10, + 26, + 6, + 22, + 14, + 30, + 1, + 17, + 9, + 25, + 5, + 21, + 13, + 29, + 3, + 19, + 11, + 27, + 7, + 23, + 15, + 31, + 32, + 48, + 40, + 56, + 36, + 52, + 44, + 60, + 34, + 50, + 42, + 58, + 38, + 54, + 46, + 62, + 33, + 49, + 41, + 57, + 37, + 53, + 45, + 61, + 35, + 51, + 43, + 59, + 39, + 55, + 47, + 63 + ], + "index": 103 + }, + { + "X_character_permutation": [ + 0, + 25, + 21, + 12, + 28, + 5, + 9, + 16, + 32, + 57, + 53, + 44, + 60, + 37, + 41, + 48, + 13, + 20, + 24, + 1, + 17, + 8, + 4, + 29, + 45, + 52, + 56, + 33, + 49, + 40, + 36, + 61, + 2, + 27, + 23, + 14, + 30, + 7, + 11, + 18, + 34, + 59, + 55, + 46, + 62, + 39, + 43, + 50, + 15, + 22, + 26, + 3, + 19, + 10, + 6, + 31, + 47, + 54, + 58, + 35, + 51, + 42, + 38, + 63 + ], + "index": 104 + }, + { + "X_character_permutation": [ + 0, + 37, + 21, + 48, + 49, + 20, + 36, + 1, + 2, + 39, + 23, + 50, + 51, + 22, + 38, + 3, + 52, + 17, + 33, + 4, + 5, + 32, + 16, + 53, + 54, + 19, + 35, + 6, + 7, + 34, + 18, + 55, + 8, + 45, + 29, + 56, + 57, + 28, + 44, + 9, + 10, + 47, + 31, + 58, + 59, + 30, + 46, + 11, + 60, + 25, + 41, + 12, + 13, + 40, + 24, + 61, + 62, + 27, + 43, + 14, + 15, + 42, + 26, + 63 + ], + "index": 105 + }, + { + "X_character_permutation": [ + 0, + 25, + 32, + 57, + 13, + 20, + 45, + 52, + 2, + 27, + 34, + 59, + 15, + 22, + 47, + 54, + 28, + 5, + 60, + 37, + 17, + 8, + 49, + 40, + 30, + 7, + 62, + 39, + 19, + 10, + 51, + 42, + 21, + 12, + 53, + 44, + 24, + 1, + 56, + 33, + 23, + 14, + 55, + 46, + 26, + 3, + 58, + 35, + 9, + 16, + 41, + 48, + 4, + 29, + 36, + 61, + 11, + 18, + 43, + 50, + 6, + 31, + 38, + 63 + ], + "index": 106 + }, + { + "X_character_permutation": [ + 0, + 37, + 2, + 39, + 52, + 17, + 54, + 19, + 8, + 45, + 10, + 47, + 60, + 25, + 62, + 27, + 49, + 20, + 51, + 22, + 5, + 32, + 7, + 34, + 57, + 28, + 59, + 30, + 13, + 40, + 15, + 42, + 21, + 48, + 23, + 50, + 33, + 4, + 35, + 6, + 29, + 56, + 31, + 58, + 41, + 12, + 43, + 14, + 36, + 1, + 38, + 3, + 16, + 53, + 18, + 55, + 44, + 9, + 46, + 11, + 24, + 61, + 26, + 63 + ], + "index": 107 + }, + { + "X_character_permutation": [ + 0, + 22, + 32, + 54, + 7, + 17, + 39, + 49, + 21, + 3, + 53, + 35, + 18, + 4, + 50, + 36, + 19, + 5, + 51, + 37, + 20, + 2, + 52, + 34, + 6, + 16, + 38, + 48, + 1, + 23, + 33, + 55, + 8, + 30, + 40, + 62, + 15, + 25, + 47, + 57, + 29, + 11, + 61, + 43, + 26, + 12, + 58, + 44, + 27, + 13, + 59, + 45, + 28, + 10, + 60, + 42, + 14, + 24, + 46, + 56, + 9, + 31, + 41, + 63 + ], + "index": 108 + }, + { + "X_character_permutation": [ + 0, + 19, + 32, + 51, + 22, + 5, + 54, + 37, + 21, + 6, + 53, + 38, + 3, + 16, + 35, + 48, + 7, + 20, + 39, + 52, + 17, + 2, + 49, + 34, + 18, + 1, + 50, + 33, + 4, + 23, + 36, + 55, + 8, + 27, + 40, + 59, + 30, + 13, + 62, + 45, + 29, + 14, + 61, + 46, + 11, + 24, + 43, + 56, + 15, + 28, + 47, + 60, + 25, + 10, + 57, + 42, + 26, + 9, + 58, + 41, + 12, + 31, + 44, + 63 + ], + "index": 109 + }, + { + "X_character_permutation": [ + 0, + 13, + 2, + 15, + 25, + 20, + 27, + 22, + 21, + 24, + 23, + 26, + 12, + 1, + 14, + 3, + 28, + 17, + 30, + 19, + 5, + 8, + 7, + 10, + 9, + 4, + 11, + 6, + 16, + 29, + 18, + 31, + 32, + 45, + 34, + 47, + 57, + 52, + 59, + 54, + 53, + 56, + 55, + 58, + 44, + 33, + 46, + 35, + 60, + 49, + 62, + 51, + 37, + 40, + 39, + 42, + 41, + 36, + 43, + 38, + 48, + 61, + 50, + 63 + ], + "index": 110 + }, + { + "X_character_permutation": [ + 0, + 4, + 2, + 6, + 16, + 20, + 18, + 22, + 32, + 36, + 34, + 38, + 48, + 52, + 50, + 54, + 1, + 5, + 3, + 7, + 17, + 21, + 19, + 23, + 33, + 37, + 35, + 39, + 49, + 53, + 51, + 55, + 8, + 12, + 10, + 14, + 24, + 28, + 26, + 30, + 40, + 44, + 42, + 46, + 56, + 60, + 58, + 62, + 9, + 13, + 11, + 15, + 25, + 29, + 27, + 31, + 41, + 45, + 43, + 47, + 57, + 61, + 59, + 63 + ], + "index": 111 + }, + { + "X_character_permutation": [ + 0, + 16, + 8, + 24, + 1, + 17, + 9, + 25, + 2, + 18, + 10, + 26, + 3, + 19, + 11, + 27, + 4, + 20, + 12, + 28, + 5, + 21, + 13, + 29, + 6, + 22, + 14, + 30, + 7, + 23, + 15, + 31, + 32, + 48, + 40, + 56, + 33, + 49, + 41, + 57, + 34, + 50, + 42, + 58, + 35, + 51, + 43, + 59, + 36, + 52, + 44, + 60, + 37, + 53, + 45, + 61, + 38, + 54, + 46, + 62, + 39, + 55, + 47, + 63 + ], + "index": 112 + }, + { + "X_character_permutation": [ + 0, + 4, + 32, + 36, + 1, + 5, + 33, + 37, + 8, + 12, + 40, + 44, + 9, + 13, + 41, + 45, + 16, + 20, + 48, + 52, + 17, + 21, + 49, + 53, + 24, + 28, + 56, + 60, + 25, + 29, + 57, + 61, + 2, + 6, + 34, + 38, + 3, + 7, + 35, + 39, + 10, + 14, + 42, + 46, + 11, + 15, + 43, + 47, + 18, + 22, + 50, + 54, + 19, + 23, + 51, + 55, + 26, + 30, + 58, + 62, + 27, + 31, + 59, + 63 + ], + "index": 113 + }, + { + "X_character_permutation": [ + 0, + 16, + 2, + 18, + 4, + 20, + 6, + 22, + 32, + 48, + 34, + 50, + 36, + 52, + 38, + 54, + 1, + 17, + 3, + 19, + 5, + 21, + 7, + 23, + 33, + 49, + 35, + 51, + 37, + 53, + 39, + 55, + 8, + 24, + 10, + 26, + 12, + 28, + 14, + 30, + 40, + 56, + 42, + 58, + 44, + 60, + 46, + 62, + 9, + 25, + 11, + 27, + 13, + 29, + 15, + 31, + 41, + 57, + 43, + 59, + 45, + 61, + 47, + 63 + ], + "index": 114 + }, + { + "X_character_permutation": [ + 0, + 25, + 2, + 27, + 13, + 20, + 15, + 22, + 21, + 12, + 23, + 14, + 24, + 1, + 26, + 3, + 28, + 5, + 30, + 7, + 17, + 8, + 19, + 10, + 9, + 16, + 11, + 18, + 4, + 29, + 6, + 31, + 32, + 57, + 34, + 59, + 45, + 52, + 47, + 54, + 53, + 44, + 55, + 46, + 56, + 33, + 58, + 35, + 60, + 37, + 62, + 39, + 49, + 40, + 51, + 42, + 41, + 48, + 43, + 50, + 36, + 61, + 38, + 63 + ], + "index": 115 + }, + { + "X_character_permutation": [ + 0, + 37, + 8, + 45, + 52, + 17, + 60, + 25, + 21, + 48, + 29, + 56, + 33, + 4, + 41, + 12, + 49, + 20, + 57, + 28, + 5, + 32, + 13, + 40, + 36, + 1, + 44, + 9, + 16, + 53, + 24, + 61, + 2, + 39, + 10, + 47, + 54, + 19, + 62, + 27, + 23, + 50, + 31, + 58, + 35, + 6, + 43, + 14, + 51, + 22, + 59, + 30, + 7, + 34, + 15, + 42, + 38, + 3, + 46, + 11, + 18, + 55, + 26, + 63 + ], + "index": 116 + }, + { + "X_character_permutation": [ + 0, + 22, + 8, + 30, + 7, + 17, + 15, + 25, + 32, + 54, + 40, + 62, + 39, + 49, + 47, + 57, + 19, + 5, + 27, + 13, + 20, + 2, + 28, + 10, + 51, + 37, + 59, + 45, + 52, + 34, + 60, + 42, + 21, + 3, + 29, + 11, + 18, + 4, + 26, + 12, + 53, + 35, + 61, + 43, + 50, + 36, + 58, + 44, + 6, + 16, + 14, + 24, + 1, + 23, + 9, + 31, + 38, + 48, + 46, + 56, + 33, + 55, + 41, + 63 + ], + "index": 117 + }, + { + "X_character_permutation": [ + 0, + 49, + 2, + 51, + 37, + 20, + 39, + 22, + 8, + 57, + 10, + 59, + 45, + 28, + 47, + 30, + 52, + 5, + 54, + 7, + 17, + 32, + 19, + 34, + 60, + 13, + 62, + 15, + 25, + 40, + 27, + 42, + 21, + 36, + 23, + 38, + 48, + 1, + 50, + 3, + 29, + 44, + 31, + 46, + 56, + 9, + 58, + 11, + 33, + 16, + 35, + 18, + 4, + 53, + 6, + 55, + 41, + 24, + 43, + 26, + 12, + 61, + 14, + 63 + ], + "index": 118 + }, + { + "X_character_permutation": [ + 0, + 7, + 8, + 15, + 22, + 17, + 30, + 25, + 32, + 39, + 40, + 47, + 54, + 49, + 62, + 57, + 19, + 20, + 27, + 28, + 5, + 2, + 13, + 10, + 51, + 52, + 59, + 60, + 37, + 34, + 45, + 42, + 21, + 18, + 29, + 26, + 3, + 4, + 11, + 12, + 53, + 50, + 61, + 58, + 35, + 36, + 43, + 44, + 6, + 1, + 14, + 9, + 16, + 23, + 24, + 31, + 38, + 33, + 46, + 41, + 48, + 55, + 56, + 63 + ], + "index": 119 + }, + { + "X_character_permutation": [ + 0, + 52, + 21, + 33, + 37, + 17, + 48, + 4, + 2, + 54, + 23, + 35, + 39, + 19, + 50, + 6, + 49, + 5, + 36, + 16, + 20, + 32, + 1, + 53, + 51, + 7, + 38, + 18, + 22, + 34, + 3, + 55, + 8, + 60, + 29, + 41, + 45, + 25, + 56, + 12, + 10, + 62, + 31, + 43, + 47, + 27, + 58, + 14, + 57, + 13, + 44, + 24, + 28, + 40, + 9, + 61, + 59, + 15, + 46, + 26, + 30, + 42, + 11, + 63 + ], + "index": 120 + }, + { + "X_character_permutation": [ + 0, + 49, + 21, + 36, + 37, + 20, + 48, + 1, + 2, + 51, + 23, + 38, + 39, + 22, + 50, + 3, + 52, + 5, + 33, + 16, + 17, + 32, + 4, + 53, + 54, + 7, + 35, + 18, + 19, + 34, + 6, + 55, + 8, + 57, + 29, + 44, + 45, + 28, + 56, + 9, + 10, + 59, + 31, + 46, + 47, + 30, + 58, + 11, + 60, + 13, + 41, + 24, + 25, + 40, + 12, + 61, + 62, + 15, + 43, + 26, + 27, + 42, + 14, + 63 + ], + "index": 121 + }, + { + "X_character_permutation": [ + 0, + 7, + 21, + 18, + 22, + 17, + 3, + 4, + 8, + 15, + 29, + 26, + 30, + 25, + 11, + 12, + 19, + 20, + 6, + 1, + 5, + 2, + 16, + 23, + 27, + 28, + 14, + 9, + 13, + 10, + 24, + 31, + 32, + 39, + 53, + 50, + 54, + 49, + 35, + 36, + 40, + 47, + 61, + 58, + 62, + 57, + 43, + 44, + 51, + 52, + 38, + 33, + 37, + 34, + 48, + 55, + 59, + 60, + 46, + 41, + 45, + 42, + 56, + 63 + ], + "index": 122 + }, + { + "X_character_permutation": [ + 0, + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 2, + 6, + 10, + 14, + 18, + 22, + 26, + 30, + 1, + 5, + 9, + 13, + 17, + 21, + 25, + 29, + 3, + 7, + 11, + 15, + 19, + 23, + 27, + 31, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 34, + 38, + 42, + 46, + 50, + 54, + 58, + 62, + 33, + 37, + 41, + 45, + 49, + 53, + 57, + 61, + 35, + 39, + 43, + 47, + 51, + 55, + 59, + 63 + ], + "index": 123 + }, + { + "X_character_permutation": [ + 0, + 16, + 32, + 48, + 1, + 17, + 33, + 49, + 8, + 24, + 40, + 56, + 9, + 25, + 41, + 57, + 4, + 20, + 36, + 52, + 5, + 21, + 37, + 53, + 12, + 28, + 44, + 60, + 13, + 29, + 45, + 61, + 2, + 18, + 34, + 50, + 3, + 19, + 35, + 51, + 10, + 26, + 42, + 58, + 11, + 27, + 43, + 59, + 6, + 22, + 38, + 54, + 7, + 23, + 39, + 55, + 14, + 30, + 46, + 62, + 15, + 31, + 47, + 63 + ], + "index": 124 + }, + { + "X_character_permutation": [ + 0, + 52, + 2, + 54, + 37, + 17, + 39, + 19, + 8, + 60, + 10, + 62, + 45, + 25, + 47, + 27, + 49, + 5, + 51, + 7, + 20, + 32, + 22, + 34, + 57, + 13, + 59, + 15, + 28, + 40, + 30, + 42, + 21, + 33, + 23, + 35, + 48, + 4, + 50, + 6, + 29, + 41, + 31, + 43, + 56, + 12, + 58, + 14, + 36, + 16, + 38, + 18, + 1, + 53, + 3, + 55, + 44, + 24, + 46, + 26, + 9, + 61, + 11, + 63 + ], + "index": 125 + }, + { + "X_character_permutation": [ + 0, + 19, + 32, + 51, + 7, + 20, + 39, + 52, + 21, + 6, + 53, + 38, + 18, + 1, + 50, + 33, + 22, + 5, + 54, + 37, + 17, + 2, + 49, + 34, + 3, + 16, + 35, + 48, + 4, + 23, + 36, + 55, + 8, + 27, + 40, + 59, + 15, + 28, + 47, + 60, + 29, + 14, + 61, + 46, + 26, + 9, + 58, + 41, + 30, + 13, + 62, + 45, + 25, + 10, + 57, + 42, + 11, + 24, + 43, + 56, + 12, + 31, + 44, + 63 + ], + "index": 126 + }, + { + "X_character_permutation": [ + 0, + 13, + 2, + 15, + 28, + 17, + 30, + 19, + 21, + 24, + 23, + 26, + 9, + 4, + 11, + 6, + 25, + 20, + 27, + 22, + 5, + 8, + 7, + 10, + 12, + 1, + 14, + 3, + 16, + 29, + 18, + 31, + 32, + 45, + 34, + 47, + 60, + 49, + 62, + 51, + 53, + 56, + 55, + 58, + 41, + 36, + 43, + 38, + 57, + 52, + 59, + 54, + 37, + 40, + 39, + 42, + 44, + 33, + 46, + 35, + 48, + 61, + 50, + 63 + ], + "index": 127 + }, + { + "X_character_permutation": [ + 0, + 28, + 21, + 9, + 13, + 17, + 24, + 4, + 32, + 60, + 53, + 41, + 45, + 49, + 56, + 36, + 25, + 5, + 12, + 16, + 20, + 8, + 1, + 29, + 57, + 37, + 44, + 48, + 52, + 40, + 33, + 61, + 2, + 30, + 23, + 11, + 15, + 19, + 26, + 6, + 34, + 62, + 55, + 43, + 47, + 51, + 58, + 38, + 27, + 7, + 14, + 18, + 22, + 10, + 3, + 31, + 59, + 39, + 46, + 50, + 54, + 42, + 35, + 63 + ], + "index": 128 + }, + { + "X_character_permutation": [ + 0, + 19, + 21, + 6, + 7, + 20, + 18, + 1, + 8, + 27, + 29, + 14, + 15, + 28, + 26, + 9, + 22, + 5, + 3, + 16, + 17, + 2, + 4, + 23, + 30, + 13, + 11, + 24, + 25, + 10, + 12, + 31, + 32, + 51, + 53, + 38, + 39, + 52, + 50, + 33, + 40, + 59, + 61, + 46, + 47, + 60, + 58, + 41, + 54, + 37, + 35, + 48, + 49, + 34, + 36, + 55, + 62, + 45, + 43, + 56, + 57, + 42, + 44, + 63 + ], + "index": 129 + }, + { + "X_character_permutation": [ + 0, + 13, + 21, + 24, + 28, + 17, + 9, + 4, + 32, + 45, + 53, + 56, + 60, + 49, + 41, + 36, + 25, + 20, + 12, + 1, + 5, + 8, + 16, + 29, + 57, + 52, + 44, + 33, + 37, + 40, + 48, + 61, + 2, + 15, + 23, + 26, + 30, + 19, + 11, + 6, + 34, + 47, + 55, + 58, + 62, + 51, + 43, + 38, + 27, + 22, + 14, + 3, + 7, + 10, + 18, + 31, + 59, + 54, + 46, + 35, + 39, + 42, + 50, + 63 + ], + "index": 130 + }, + { + "X_character_permutation": [ + 0, + 28, + 2, + 30, + 13, + 17, + 15, + 19, + 21, + 9, + 23, + 11, + 24, + 4, + 26, + 6, + 25, + 5, + 27, + 7, + 20, + 8, + 22, + 10, + 12, + 16, + 14, + 18, + 1, + 29, + 3, + 31, + 32, + 60, + 34, + 62, + 45, + 49, + 47, + 51, + 53, + 41, + 55, + 43, + 56, + 36, + 58, + 38, + 57, + 37, + 59, + 39, + 52, + 40, + 54, + 42, + 44, + 48, + 46, + 50, + 33, + 61, + 35, + 63 + ], + "index": 131 + }, + { + "X_character_permutation": [ + 0, + 19, + 32, + 51, + 7, + 20, + 39, + 52, + 8, + 27, + 40, + 59, + 15, + 28, + 47, + 60, + 22, + 5, + 54, + 37, + 17, + 2, + 49, + 34, + 30, + 13, + 62, + 45, + 25, + 10, + 57, + 42, + 21, + 6, + 53, + 38, + 18, + 1, + 50, + 33, + 29, + 14, + 61, + 46, + 26, + 9, + 58, + 41, + 3, + 16, + 35, + 48, + 4, + 23, + 36, + 55, + 11, + 24, + 43, + 56, + 12, + 31, + 44, + 63 + ], + "index": 132 + }, + { + "X_character_permutation": [ + 0, + 13, + 2, + 15, + 28, + 17, + 30, + 19, + 32, + 45, + 34, + 47, + 60, + 49, + 62, + 51, + 25, + 20, + 27, + 22, + 5, + 8, + 7, + 10, + 57, + 52, + 59, + 54, + 37, + 40, + 39, + 42, + 21, + 24, + 23, + 26, + 9, + 4, + 11, + 6, + 53, + 56, + 55, + 58, + 41, + 36, + 43, + 38, + 12, + 1, + 14, + 3, + 16, + 29, + 18, + 31, + 44, + 33, + 46, + 35, + 48, + 61, + 50, + 63 + ], + "index": 133 + }, + { + "X_character_permutation": [ + 0, + 1, + 32, + 33, + 16, + 17, + 48, + 49, + 2, + 3, + 34, + 35, + 18, + 19, + 50, + 51, + 4, + 5, + 36, + 37, + 20, + 21, + 52, + 53, + 6, + 7, + 38, + 39, + 22, + 23, + 54, + 55, + 8, + 9, + 40, + 41, + 24, + 25, + 56, + 57, + 10, + 11, + 42, + 43, + 26, + 27, + 58, + 59, + 12, + 13, + 44, + 45, + 28, + 29, + 60, + 61, + 14, + 15, + 46, + 47, + 30, + 31, + 62, + 63 + ], + "index": 134 + }, + { + "X_character_permutation": [ + 0, + 4, + 32, + 36, + 16, + 20, + 48, + 52, + 2, + 6, + 34, + 38, + 18, + 22, + 50, + 54, + 1, + 5, + 33, + 37, + 17, + 21, + 49, + 53, + 3, + 7, + 35, + 39, + 19, + 23, + 51, + 55, + 8, + 12, + 40, + 44, + 24, + 28, + 56, + 60, + 10, + 14, + 42, + 46, + 26, + 30, + 58, + 62, + 9, + 13, + 41, + 45, + 25, + 29, + 57, + 61, + 11, + 15, + 43, + 47, + 27, + 31, + 59, + 63 + ], + "index": 135 + }, + { + "X_character_permutation": [ + 0, + 16, + 2, + 18, + 1, + 17, + 3, + 19, + 8, + 24, + 10, + 26, + 9, + 25, + 11, + 27, + 4, + 20, + 6, + 22, + 5, + 21, + 7, + 23, + 12, + 28, + 14, + 30, + 13, + 29, + 15, + 31, + 32, + 48, + 34, + 50, + 33, + 49, + 35, + 51, + 40, + 56, + 42, + 58, + 41, + 57, + 43, + 59, + 36, + 52, + 38, + 54, + 37, + 53, + 39, + 55, + 44, + 60, + 46, + 62, + 45, + 61, + 47, + 63 + ], + "index": 136 + }, + { + "X_character_permutation": [ + 0, + 25, + 21, + 12, + 13, + 20, + 24, + 1, + 2, + 27, + 23, + 14, + 15, + 22, + 26, + 3, + 28, + 5, + 9, + 16, + 17, + 8, + 4, + 29, + 30, + 7, + 11, + 18, + 19, + 10, + 6, + 31, + 32, + 57, + 53, + 44, + 45, + 52, + 56, + 33, + 34, + 59, + 55, + 46, + 47, + 54, + 58, + 35, + 60, + 37, + 41, + 48, + 49, + 40, + 36, + 61, + 62, + 39, + 43, + 50, + 51, + 42, + 38, + 63 + ], + "index": 137 + }, + { + "X_character_permutation": [ + 0, + 37, + 21, + 48, + 52, + 17, + 33, + 4, + 8, + 45, + 29, + 56, + 60, + 25, + 41, + 12, + 49, + 20, + 36, + 1, + 5, + 32, + 16, + 53, + 57, + 28, + 44, + 9, + 13, + 40, + 24, + 61, + 2, + 39, + 23, + 50, + 54, + 19, + 35, + 6, + 10, + 47, + 31, + 58, + 62, + 27, + 43, + 14, + 51, + 22, + 38, + 3, + 7, + 34, + 18, + 55, + 59, + 30, + 46, + 11, + 15, + 42, + 26, + 63 + ], + "index": 138 + }, + { + "X_character_permutation": [ + 0, + 22, + 32, + 54, + 7, + 17, + 39, + 49, + 8, + 30, + 40, + 62, + 15, + 25, + 47, + 57, + 19, + 5, + 51, + 37, + 20, + 2, + 52, + 34, + 27, + 13, + 59, + 45, + 28, + 10, + 60, + 42, + 21, + 3, + 53, + 35, + 18, + 4, + 50, + 36, + 29, + 11, + 61, + 43, + 26, + 12, + 58, + 44, + 6, + 16, + 38, + 48, + 1, + 23, + 33, + 55, + 14, + 24, + 46, + 56, + 9, + 31, + 41, + 63 + ], + "index": 139 + }, + { + "X_character_permutation": [ + 0, + 49, + 2, + 51, + 37, + 20, + 39, + 22, + 21, + 36, + 23, + 38, + 48, + 1, + 50, + 3, + 52, + 5, + 54, + 7, + 17, + 32, + 19, + 34, + 33, + 16, + 35, + 18, + 4, + 53, + 6, + 55, + 8, + 57, + 10, + 59, + 45, + 28, + 47, + 30, + 29, + 44, + 31, + 46, + 56, + 9, + 58, + 11, + 60, + 13, + 62, + 15, + 25, + 40, + 27, + 42, + 41, + 24, + 43, + 26, + 12, + 61, + 14, + 63 + ], + "index": 140 + }, + { + "X_character_permutation": [ + 0, + 7, + 8, + 15, + 22, + 17, + 30, + 25, + 21, + 18, + 29, + 26, + 3, + 4, + 11, + 12, + 19, + 20, + 27, + 28, + 5, + 2, + 13, + 10, + 6, + 1, + 14, + 9, + 16, + 23, + 24, + 31, + 32, + 39, + 40, + 47, + 54, + 49, + 62, + 57, + 53, + 50, + 61, + 58, + 35, + 36, + 43, + 44, + 51, + 52, + 59, + 60, + 37, + 34, + 45, + 42, + 38, + 33, + 46, + 41, + 48, + 55, + 56, + 63 + ], + "index": 141 + }, + { + "X_character_permutation": [ + 0, + 1, + 8, + 9, + 16, + 17, + 24, + 25, + 32, + 33, + 40, + 41, + 48, + 49, + 56, + 57, + 4, + 5, + 12, + 13, + 20, + 21, + 28, + 29, + 36, + 37, + 44, + 45, + 52, + 53, + 60, + 61, + 2, + 3, + 10, + 11, + 18, + 19, + 26, + 27, + 34, + 35, + 42, + 43, + 50, + 51, + 58, + 59, + 6, + 7, + 14, + 15, + 22, + 23, + 30, + 31, + 38, + 39, + 46, + 47, + 54, + 55, + 62, + 63 + ], + "index": 142 + }, + { + "X_character_permutation": [ + 0, + 4, + 2, + 6, + 16, + 20, + 18, + 22, + 8, + 12, + 10, + 14, + 24, + 28, + 26, + 30, + 1, + 5, + 3, + 7, + 17, + 21, + 19, + 23, + 9, + 13, + 11, + 15, + 25, + 29, + 27, + 31, + 32, + 36, + 34, + 38, + 48, + 52, + 50, + 54, + 40, + 44, + 42, + 46, + 56, + 60, + 58, + 62, + 33, + 37, + 35, + 39, + 49, + 53, + 51, + 55, + 41, + 45, + 43, + 47, + 57, + 61, + 59, + 63 + ], + "index": 143 + }, + { + "X_character_permutation": [ + 0, + 16, + 8, + 24, + 1, + 17, + 9, + 25, + 32, + 48, + 40, + 56, + 33, + 49, + 41, + 57, + 4, + 20, + 12, + 28, + 5, + 21, + 13, + 29, + 36, + 52, + 44, + 60, + 37, + 53, + 45, + 61, + 2, + 18, + 10, + 26, + 3, + 19, + 11, + 27, + 34, + 50, + 42, + 58, + 35, + 51, + 43, + 59, + 6, + 22, + 14, + 30, + 7, + 23, + 15, + 31, + 38, + 54, + 46, + 62, + 39, + 55, + 47, + 63 + ], + "index": 144 + }, + { + "X_character_permutation": [ + 0, + 22, + 8, + 30, + 7, + 17, + 15, + 25, + 21, + 3, + 29, + 11, + 18, + 4, + 26, + 12, + 19, + 5, + 27, + 13, + 20, + 2, + 28, + 10, + 6, + 16, + 14, + 24, + 1, + 23, + 9, + 31, + 32, + 54, + 40, + 62, + 39, + 49, + 47, + 57, + 53, + 35, + 61, + 43, + 50, + 36, + 58, + 44, + 51, + 37, + 59, + 45, + 52, + 34, + 60, + 42, + 38, + 48, + 46, + 56, + 33, + 55, + 41, + 63 + ], + "index": 145 + }, + { + "X_character_permutation": [ + 0, + 52, + 8, + 60, + 37, + 17, + 45, + 25, + 2, + 54, + 10, + 62, + 39, + 19, + 47, + 27, + 49, + 5, + 57, + 13, + 20, + 32, + 28, + 40, + 51, + 7, + 59, + 15, + 22, + 34, + 30, + 42, + 21, + 33, + 29, + 41, + 48, + 4, + 56, + 12, + 23, + 35, + 31, + 43, + 50, + 6, + 58, + 14, + 36, + 16, + 44, + 24, + 1, + 53, + 9, + 61, + 38, + 18, + 46, + 26, + 3, + 55, + 11, + 63 + ], + "index": 146 + }, + { + "X_character_permutation": [ + 0, + 52, + 21, + 33, + 37, + 17, + 48, + 4, + 8, + 60, + 29, + 41, + 45, + 25, + 56, + 12, + 49, + 5, + 36, + 16, + 20, + 32, + 1, + 53, + 57, + 13, + 44, + 24, + 28, + 40, + 9, + 61, + 2, + 54, + 23, + 35, + 39, + 19, + 50, + 6, + 10, + 62, + 31, + 43, + 47, + 27, + 58, + 14, + 51, + 7, + 38, + 18, + 22, + 34, + 3, + 55, + 59, + 15, + 46, + 26, + 30, + 42, + 11, + 63 + ], + "index": 147 + }, + { + "X_character_permutation": [ + 0, + 1, + 2, + 3, + 16, + 17, + 18, + 19, + 8, + 9, + 10, + 11, + 24, + 25, + 26, + 27, + 4, + 5, + 6, + 7, + 20, + 21, + 22, + 23, + 12, + 13, + 14, + 15, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 48, + 49, + 50, + 51, + 40, + 41, + 42, + 43, + 56, + 57, + 58, + 59, + 36, + 37, + 38, + 39, + 52, + 53, + 54, + 55, + 44, + 45, + 46, + 47, + 60, + 61, + 62, + 63 + ], + "index": 148 + }, + { + "X_character_permutation": [ + 0, + 28, + 32, + 60, + 13, + 17, + 45, + 49, + 21, + 9, + 53, + 41, + 24, + 4, + 56, + 36, + 25, + 5, + 57, + 37, + 20, + 8, + 52, + 40, + 12, + 16, + 44, + 48, + 1, + 29, + 33, + 61, + 2, + 30, + 34, + 62, + 15, + 19, + 47, + 51, + 23, + 11, + 55, + 43, + 26, + 6, + 58, + 38, + 27, + 7, + 59, + 39, + 22, + 10, + 54, + 42, + 14, + 18, + 46, + 50, + 3, + 31, + 35, + 63 + ], + "index": 149 + }, + { + "X_character_permutation": [ + 0, + 28, + 21, + 9, + 13, + 17, + 24, + 4, + 2, + 30, + 23, + 11, + 15, + 19, + 26, + 6, + 25, + 5, + 12, + 16, + 20, + 8, + 1, + 29, + 27, + 7, + 14, + 18, + 22, + 10, + 3, + 31, + 32, + 60, + 53, + 41, + 45, + 49, + 56, + 36, + 34, + 62, + 55, + 43, + 47, + 51, + 58, + 38, + 57, + 37, + 44, + 48, + 52, + 40, + 33, + 61, + 59, + 39, + 46, + 50, + 54, + 42, + 35, + 63 + ], + "index": 150 + }, + { + "X_character_permutation": [ + 0, + 28, + 32, + 60, + 13, + 17, + 45, + 49, + 2, + 30, + 34, + 62, + 15, + 19, + 47, + 51, + 25, + 5, + 57, + 37, + 20, + 8, + 52, + 40, + 27, + 7, + 59, + 39, + 22, + 10, + 54, + 42, + 21, + 9, + 53, + 41, + 24, + 4, + 56, + 36, + 23, + 11, + 55, + 43, + 26, + 6, + 58, + 38, + 12, + 16, + 44, + 48, + 1, + 29, + 33, + 61, + 14, + 18, + 46, + 50, + 3, + 31, + 35, + 63 + ], + "index": 151 + }, + { + "X_character_permutation": [ + 0, + 1, + 32, + 33, + 16, + 17, + 48, + 49, + 8, + 9, + 40, + 41, + 24, + 25, + 56, + 57, + 4, + 5, + 36, + 37, + 20, + 21, + 52, + 53, + 12, + 13, + 44, + 45, + 28, + 29, + 60, + 61, + 2, + 3, + 34, + 35, + 18, + 19, + 50, + 51, + 10, + 11, + 42, + 43, + 26, + 27, + 58, + 59, + 6, + 7, + 38, + 39, + 22, + 23, + 54, + 55, + 14, + 15, + 46, + 47, + 30, + 31, + 62, + 63 + ], + "index": 152 + }, + { + "X_character_permutation": [ + 0, + 22, + 21, + 3, + 7, + 17, + 18, + 4, + 8, + 30, + 29, + 11, + 15, + 25, + 26, + 12, + 19, + 5, + 6, + 16, + 20, + 2, + 1, + 23, + 27, + 13, + 14, + 24, + 28, + 10, + 9, + 31, + 32, + 54, + 53, + 35, + 39, + 49, + 50, + 36, + 40, + 62, + 61, + 43, + 47, + 57, + 58, + 44, + 51, + 37, + 38, + 48, + 52, + 34, + 33, + 55, + 59, + 45, + 46, + 56, + 60, + 42, + 41, + 63 + ], + "index": 153 + }, + { + "X_character_permutation": [ + 0, + 52, + 8, + 60, + 37, + 17, + 45, + 25, + 21, + 33, + 29, + 41, + 48, + 4, + 56, + 12, + 49, + 5, + 57, + 13, + 20, + 32, + 28, + 40, + 36, + 16, + 44, + 24, + 1, + 53, + 9, + 61, + 2, + 54, + 10, + 62, + 39, + 19, + 47, + 27, + 23, + 35, + 31, + 43, + 50, + 6, + 58, + 14, + 51, + 7, + 59, + 15, + 22, + 34, + 30, + 42, + 38, + 18, + 46, + 26, + 3, + 55, + 11, + 63 + ], + "index": 154 + }, + { + "X_character_permutation": [ + 0, + 1, + 8, + 9, + 16, + 17, + 24, + 25, + 2, + 3, + 10, + 11, + 18, + 19, + 26, + 27, + 4, + 5, + 12, + 13, + 20, + 21, + 28, + 29, + 6, + 7, + 14, + 15, + 22, + 23, + 30, + 31, + 32, + 33, + 40, + 41, + 48, + 49, + 56, + 57, + 34, + 35, + 42, + 43, + 50, + 51, + 58, + 59, + 36, + 37, + 44, + 45, + 52, + 53, + 60, + 61, + 38, + 39, + 46, + 47, + 54, + 55, + 62, + 63 + ], + "index": 155 + } + ], + "hits_by_f_mod4": { + "0": [], + "1": [], + "2": [], + "3": [] + }, + "limits": [ + "Fixed alternating bank pattern and fixed four-route sequence only; this is not all possible five-query words.", + "Extra internal scalar bank phases, PauliZ routes, other ADDRESSs or additional route slots are outside the declared grammar.", + "A positive group-algebra endpoint still needs its complete literal dyadic ADD/ADDRESS factorization before being priced as a caller." + ], + "no_new_kappa": true, + "producer_sha256": "59fe8f29770c7ec7e75b5ab29716f1dd7a35404e74919e5370bc04cc2df41c86", + "query_alphabet": [ + { + "kind": "N", + "negative": false, + "operator": 1, + "plane": 0, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 1, + "plane": 0, + "scalar_phase": 3 + }, + { + "kind": "N", + "negative": false, + "operator": 2, + "plane": 1, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 2, + "plane": 1, + "scalar_phase": 3 + }, + { + "kind": "N", + "negative": false, + "operator": 3, + "plane": 2, + "scalar_phase": 1 + }, + { + "kind": "N", + "negative": true, + "operator": 3, + "plane": 2, + "scalar_phase": 3 + }, + { + "kind": "A", + "negative": false, + "operator": 9, + "plane": 0, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 9, + "plane": 0, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 11, + "plane": 1, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 11, + "plane": 1, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 13, + "plane": 2, + "reflection": 0, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 13, + "plane": 2, + "reflection": 0, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 299, + "plane": 0, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 299, + "plane": 0, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 301, + "plane": 1, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 301, + "plane": 1, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 303, + "plane": 2, + "reflection": 1, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 303, + "plane": 2, + "reflection": 1, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 305, + "plane": 0, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 305, + "plane": 0, + "reflection": 2, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 307, + "plane": 1, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 307, + "plane": 1, + "reflection": 2, + "scalar_phase": 2 + }, + { + "kind": "A", + "negative": false, + "operator": 309, + "plane": 2, + "reflection": 2, + "scalar_phase": 0 + }, + { + "kind": "A", + "negative": true, + "operator": 309, + "plane": 2, + "reflection": 2, + "scalar_phase": 2 + }, + { + "ADDRESS_plane_swap": 2, + "kind": "B_full_conjugate", + "negative": false, + "operator": 311, + "plane": 0, + "reflection": 0, + "scalar_phase": 0 + }, + { + "ADDRESS_plane_swap": 2, + "kind": "B_full_conjugate", + "negative": true, + "operator": 311, + "plane": 0, + "reflection": 0, + "scalar_phase": 2 + } + ], + "residue_completion_hits": 0, + "routing_reflection_pattern": [ + 0, + 1, + 2, + 0 + ], + "singleton_ray_rejections": 11881376, + "source_pins": [ + { + "path": "/Users/ross/git/math/.research-automation/runs/kappa-four-coordinate-20261019T0717Z/q4-pauli-fusion/unpaired_reflection_screen.py", + "sha256": "cc385b510da37946acc0f9882f74d30f3431e8c9ef9e99dd5699aeaa81ec531e" + } + ], + "status": "PASS_EXACT_BOUNDED_VARIED_REFLECTION_SCREEN", + "target": "diag(E3,E3), E3=N0*N1*N2; five rank2f native queries versus stock6 rank2f.", + "tensor_model": { + "base_dimension": 64, + "exact_monomials": 1532730, + "exact_rays": 1399840 + }, + "words": 11881376 +} diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/one_query_endpoint_obstruction.py b/research/one-query-endpoint-scan/source/q4-pauli-fusion/one_query_endpoint_obstruction.py new file mode 100644 index 0000000000..9bb78be728 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/one_query_endpoint_obstruction.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""Actual-base sparsity certificate for the changed two-carrier gate. + +The general two-column argument and its two independent all-size proofs +are written in ONE-QUERY-ENDPOINT-OBSTRUCTION.md. This producer checks +actual Gaussian matrices, not a native-arity label inferred from a word. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from collections import Counter +from fractions import Fraction +import argparse +import hashlib +import json +from reflection_route_pruned import EnlargedBase +from unpaired_reflection_screen import need + +HERE = Path(__file__).resolve().parent + + +def walsh(values): + out = list(values) + step = 1 + while step < len(out): + for first in range(0, len(out), 2 * step): + for j in range(first, first + step): + a, b = out[j], out[j + step] + out[j] = a[0] + b[0], a[1] + b[1] + out[j + step] = a[0] - b[0], a[1] - b[1] + step *= 2 + return out + + +def physical_certificate(A, op): + permutation, phases = A.ops[op] + units = ((1, 0), (0, 1), (-1, 0), (0, -1)) + rows = [] + for x in range(64): + values = [] + for w in range(64): + a, b = units[phases[w]] + sign = -1 if (x & permutation[w]).bit_count() & 1 else 1 + values.append((sign * a, sign * b)) + rows.append(walsh(values)) + support = [sum(rows[x][y] != (0, 0) for x in range(64)) for y in range(64)] + norms = sorted({a * a + b * b for row in rows for a, b in row if (a, b) != (0, 0)}) + # This independent actual-column unitary check is sensitive to Gaussian + # phases, the Walsh conjugation and all64 independent input columns. + for j in range(64): + for k in range(64): + real, imag = 0, 0 + for row in rows: + a, b = row[j] + c, d = row[k] + real += a * c + b * d + imag += a * d - b * c + need((real, imag) == ((4096, 0) if j == k else (0, 0)), + 'all physical Gaussian columns are exactly unitary') + return dict(matrix_dimension=64, common_denominator=64, + column_support_histogram=dict(Counter(support)), + nonzero_entry_squared_integer_norms=norms, + maximum_entry_squared_modulus=str(Fraction(max(norms), 4096)), + exact_integer_matrix_sha256=hashlib.sha256( + json.dumps(rows, separators=(',', ':')).encode()).hexdigest()) + + +def run(): + A = EnlargedBase(True) + operators = [('H0=-i*N0_1', A.H[0], 'native')] + for kind, reflections in (('primal', A.Rs), ('dual', A.dual)): + for j, R in enumerate(reflections): + for i, H in enumerate(A.H): + operators.append((f'{kind}_Q_reflection{j}_plane{i}', + A.left(H, A.left(R, H)), 'native')) + operators.append(('R0_actual_ADDRESS_control', A.Rs[0], 'monomial')) + cases = [] + for name, op, kind in operators: + certificate = physical_certificate(A, op) + need(certificate['column_support_histogram'] == ({4: 64} if kind == 'native' else {1: 64}), + 'actual admitted native and monomial controls have the predicted physical sparsity') + need(certificate['maximum_entry_squared_modulus'] == ('1/4' if kind == 'native' else '1'), + 'actual Gaussian maximum amplitude establishes the uncertainty tariff') + cases.append(dict(name=name, kind=kind, certificate=certificate)) + # Exact sharp control for Cauchy's support uncertainty: a coordinate + # vector under a4-flat-column native has support product4, not1. + need(1 * 4 == 4 and 1 * 1 < 4, + 'the actual one-query native uncertainty bound is sensitive to an omitted support factor') + native = HERE.parent / 'native-frames' + pins = [HERE / 'unpaired_reflection_screen.py', HERE / 'varied_reflection_screen.py', + HERE / 'reflection_route_pruned.py'] + pins += [native / name for name in ('native_model.py', 'conjugated_reflection.py', + 'CONJUGATED-REFLECTION.json', 'dual_reflections.py', + 'DUAL-REFLECTIONS.json')] + return dict(status='PASS_ACTUAL_GAUSSIAN_ONE_QUERY_ENDPOINT_OBSTRUCTION', no_new_kappa=True, + target='C=[[Q-I,N],[Q,0]], two independent M-dimensional carrier banks; optionally any finite h additional M-dimensional restored identity helper banks, with one query on an M-dimensional bank.', + exact_actual_base_cases=cases, + all_size_binding='N_f=i*H0^tensorf and each primal/dualQ_f=Q_1^tensorf. The exact base maximum1/2 gives maximum2^-f at everyf; all columns remain unitary.', + finite_uniform_theorem='No one-query factorization C G=F diag(U,I) exists over a fixed finite uniform-tensor physical-monomial endpoint algebra for allf. U is arbitrary. Distinct nonproportional tensor rays are independent for all sufficiently large tensor powers, so Qg0 and Ng1 cannot both return to the monomial algebra unless the untouched column vanishes.', + nonuniform_support_theorem='For arbitrary physical monomial controllers, if endpoint block columns have at mostK_G andK_F nonzero entries, a one-query factorization requiresK_G*K_F>=2^(2f). Consequently scalar bank ADD counts obeya_F+a_G>=2f. A growingO(f)ADD word is not excluded.', + helper_dimension_contract='For h additional M-dimensional identity helper banks and one M-dimensional queried bank, unqueried input dimension (h+1)M exceeds helper image dimension hM. More generally, after the same carrier-row vanishing, helper widths totaling K and query width w<=M give 2M+K-w>=M+K>K. No arbitrarily larger single queried helper bank is admitted.', + exact_support_thresholds=[dict(f=f, required_support_product_at_least=4 ** f, + required_scalar_bank_ADDs_at_least=2 * f) + for f in range(1, 17)], + limits=['The nonuniform theorem is a support/scan lower bound, not an impossibility result forO(f)ADD words.', + 'Finite uniform tensor independence does not itself cover f-dependent growing nonuniform controllers.', + 'The gate is unary on one physical bank. Multi-bank native primitives or nonmonomial free endpoints are outside the premise.', + 'The helper dimension argument requires an M-dimensional queried bank, or query width<=M in the stated conditional variable-width extension; unbounded queried helper width is excluded.', + 'This is a scoped obstruction for the changed localC gate, not a complete-caller stock floor in the enlarged reflection grammar.'], + attribution='The independent-column obstruction and support-uncertainty proposal are from root. This file supplies the actual Gaussian base verification and the written all-size composition proof. Native arity and literal primal/dual recipes are from stabilizer_escape_1019.', + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + source_pins=[dict(path=str(p), sha256=hashlib.sha256(p.read_bytes()).hexdigest()) for p in pins]) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = json.loads(json.dumps(run())) + path = HERE / 'ONE-QUERY-ENDPOINT-OBSTRUCTION.json' + if args.write: + path.write_text(json.dumps(out, sort_keys=True, indent=2) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved actual one-query obstruction differs') + print(out['status'], 'actual Gaussian cases', len(out['exact_actual_base_cases'])) + + +if __name__ == '__main__': + main() diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/reflection_route_pruned.py b/research/one-query-endpoint-scan/source/q4-pauli-fusion/reflection_route_pruned.py new file mode 100644 index 0000000000..03831f301c --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/reflection_route_pruned.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +"""An exact final-row prune for one bounded five-query tensor grammar. + +No branch is rejected because of a sampled state or a floating computation. +The fifth query touches only bank0, so bank1 must already lie in the +accepted E3 times free-ADDRESS algebra. This necessary condition rejects +all26 last choices together, separately for each chunk-size residue. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from collections import Counter +import argparse +import hashlib +import json +from varied_reflection_screen import VariedBase +from unpaired_reflection_screen import need, rotate + +HERE = Path(__file__).resolve().parent + + +class EnlargedBase(VariedBase): + def __init__(self, dual): + super().__init__() + self.dual = [] + for p in (0, 2, 4): + v = sum(1 << i for i in (1, 3, 5, p)) + self.dual.append(self.intern(tuple(w ^ (v if (w & v).bit_count() & 1 else 0) + for w in range(64)), (0,) * 64)) + self.enlarged_generators = self.Rs + self.dual + for a, b in ((0, 2), (0, 4), (1, 3), (1, 5)): + perm = list(range(6)) + perm[a], perm[b] = perm[b], perm[a] + self.enlarged_generators.append(self.intern( + tuple(sum(((w >> j) & 1) << perm[j] for j in range(6)) for w in range(64)), + (0,) * 64)) + if dual: + free, todo = {self.identity}, [self.identity] + for old in todo: + for generator in self.enlarged_generators: + new = self.left(generator, old) + if new not in free: + free.add(new) + todo.append(new) + need(len(free) == 576, 'the enlarged exact free ADDRESS group has order576') + self.free = sorted(free) + self.accept = {} + for g in self.free: + need(self.left(g, self.Ebase) == self.left(self.Ebase, g), + 'every enlarged actual ADDRESS commutes exact E3') + target = self.left(g, self.Ebase) + ray, phase = self.rays[target] + need(phase == 0 and ray not in self.accept, + 'enlarged ADDRESS completions give distinct zero-phase tensor rays') + self.accept[ray] = g + self.accept_rays = set(self.accept) + + def folded(self, entry, residue): + result = {} + for op, z in entry.items(): + ray, phase = self.rays[op] + a, b = rotate(z, phase * residue) + c, d = result.get(ray, (0, 0)) + value = a + c, b + d + if value == (0, 0): + result.pop(ray, None) + else: + result[ray] = value + return result + + def last_row_residues(self, matrix): + # A singleton rejected tensor ray cannot cancel for any residue. + if self.singleton_obstruction(matrix[2:]): + return [] + return [s for s in range(4) + if all(all(ray in self.accept for ray in self.folded(entry, s)) + for entry in matrix[2:])] + + +def source_pins(): + native = HERE.parent / 'native-frames' + files = [HERE / 'unpaired_reflection_screen.py', HERE / 'varied_reflection_screen.py'] + files += [native / name for name in + ('native_model.py', 'conjugated_reflection.py', 'CONJUGATED-REFLECTION.json', + 'conjugated_factory.py', 'CONJUGATED-FACTORY.json')] + return [dict(path=str(path), sha256=hashlib.sha256(path.read_bytes()).hexdigest()) for path in files] + + +def run(dual): + A = EnlargedBase(dual) + initial = ({A.identity: (1, 0)}, {}, {}, {A.identity: (1, 0)}) + banks = [0, 1, 0, 1, 0] + routes = [A.Rs[0], A.dual[0], A.Rs[1], A.dual[1]] if dual else [A.Rs[i] for i in (0, 1, 2, 0)] + counts = Counter() + hits = {s: [] for s in range(4)} + all_hits = [] + + def visit(matrix, word, depth): + if depth == 4: + counts['four_query_prefixes'] += 1 + counts['covered_five_query_words'] += len(A.choices) + possible = A.last_row_residues(matrix) + if not possible: + counts['all_last_queries_pruned_prefixes'] += 1 + # Deterministic controls cover actual full matrices from this + # trace. They compare the prune against the unpruned test. + if counts['pruned_controls'] < 16: + for choice in A.choices: + candidate = A.apply_query(matrix, 0, choice) + need(all(A.complete(candidate, s) is None for s in range(4)), + 'last-row prune rejects only truly impossible completions') + counts['pruned_controls'] += 1 + return + counts['tested_last_query_words'] += len(A.choices) + for index, choice in enumerate(A.choices): + candidate = A.apply_query(matrix, 0, choice) + found = [] + for residue in possible: + completion = A.complete(candidate, residue) + if completion is not None: + counts['residue_completion_hits'] += 1 + found.append(completion) + if len(hits[residue]) < 3: + hits[residue].append(dict(query_choice_indices=word + [index], + completion=completion)) + if len(found) == 4: + counts['all_residue_word_hits'] += 1 + if len(all_hits) < 3: + all_hits.append(dict(query_choice_indices=word + [index], completions=found)) + return + for index, choice in enumerate(A.choices): + candidate = A.apply_query(matrix, banks[depth], choice) + candidate = A.route(candidate, routes[depth]) + visit(candidate, word + [index], depth + 1) + + visit(initial, [], 0) + need(counts['four_query_prefixes'] == 26 ** 4, 'all26^4 prefixes are covered') + need(counts['covered_five_query_words'] == 26 ** 5, 'all26^5 words are covered') + # A literal five-query positive control: with identity routes and five + # identity native placeholders, the same completion test must accept E3. + target = ({A.Ebase: (0, -16)}, {}, {}, {A.Ebase: (0, -16)}) + need(A.last_row_residues(target) == [0, 1, 2, 3], + 'a valid target is never rejected by the row prune') + need(all(A.complete(target, s) is not None for s in range(4)), + 'full target control is accepted exactly in every chunk-size residue') + orbits, pending = [], set(range(64)) + while pending: + owner = min(pending) + orbit = sorted({A.ops[g][0][owner] for g in A.free}) + orbits.append(orbit) + pending.difference_update(orbit) + return dict(status='PASS_EXACT_PRUNED_DUAL_ROUTE_SCREEN' if dual else 'PASS_EXACT_PRUNED_VARIED_ROUTE_REPLAY', + no_new_kappa=True, target='diag(E3,E3), everyf>=1, arbitrary independent inputs', + counts=dict(counts), hits_by_f_mod4=hits, all_residue_word_hits=all_hits, + bank_pattern=banks, + route_pattern=['R0', 'S0', 'R1', 'S1'] if dual else ['R0', 'R1', 'R2', 'R0'], + query_alphabet=A.choices, + exact_free_ADDRESS_group_order=len(A.free), X_character_orbits=orbits, + ADDRESS_definition='Rj transvection vector allp+qj; Sj vector allq+pj. Both act bitwise at allf. Enlarged endpoints additionally admit independent S3 permutations ofp/q chunks.', + all_f_binding='Ni,f=i*(-i*Ni,1)^tensorf. All ADDRESSs and admitted Ai/B queries tensor-lift their exact one-bit monomials. Gaussian proportional-ray phases are folded separately for all4 residues; no f1-only linear relation is used.', + paid_native_tariff='Each Ni, Aij=NiRjNi^-1 and B=N0R0P2R0N0^-1 is one independently admitted rank2f child with its literal monomial adapters. No dual conjugate query is assumed.', + prune_proof='Final query acts only onbank0. The two bank1 entries are unchanged, so their nonaccepted tensor rays cannot be repaired. Distinct base rays have independent sufficiently high tensor powers in each residue class. The row test is a necessary all-f condition, not a heuristic.', + exact_scope='Five queries; fixed alternating banks and the displayed four W routes; query alphabet exactly the serialized26 signed choices; arbitrary outer GL2 over the displayed complete finite ADDRESS group. Additional internal scalar/Pauli/ADDRESS bridges and other bank/route patterns are untested.', + controls=['Sixteen pruned actual prefixes checked against all26 unpruned last-query completions in all4 residues.', + 'Exact target diag(E3,E3) accepted by row prune and full unitary endpoint test in all4 residues.'], + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), source_pins=source_pins()) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--dual', action='store_true') + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = json.loads(json.dumps(run(args.dual))) + path = HERE / ('DUAL-REFLECTION-SCREEN.json' if args.dual else 'PRUNED-VARIED-REPLAY.json') + if args.write: + path.write_text(json.dumps(out, sort_keys=True, indent=2) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved pruned route screen differs') + print(out['status'], json.dumps(out['counts'], sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/unpaired_reflection_screen.py b/research/one-query-endpoint-scan/source/q4-pauli-fusion/unpaired_reflection_screen.py new file mode 100644 index 0000000000..053a08a5fe --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/unpaired_reflection_screen.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Five native queries and exact all-f tensor-base routing completion. + +Target: diag(E3,E3), E3=N0*N1*N2. Every internal bridge in this +screen is the same W(R), for the unpaired orthogonal reflection R. +Outer completion is arbitrary GL2(Q(i)[R]), including f mod4 phases. +Admitted A_i=N_i R N_i^-1 is charged once, with its physical tariff +proved separately by native-frames/conjugated_reflection.py. +This is a bounded changed-bridge grammar, not an all-grammar obstruction. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from collections import Counter +import argparse +import hashlib +import json + +HERE = Path(__file__).resolve().parent + + +def need(x, why): + if not x: + raise ValueError(why) + + +def rotate(z, power): + a, b = z + return ((a, b), (-b, a), (-a, -b), (b, -a))[power % 4] + + +class TensorBase: + """Actual one-bit Clifford monomials in the X-character basis.""" + def __init__(self): + self.dimension = 64 + self.ops, self.ids, self.rays, self.ray_ids, self.left_cache = [], {}, [], {}, {} + self.identity = self.intern(tuple(range(64)), (0,) * 64) + self.H = [] + for plane in range(3): + p, q = 2 * plane, 2 * plane + 1 + flip = (1 << p) | (1 << q) + self.H.append(self.intern(tuple(w ^ flip for w in range(64)), + tuple((-((w >> p) & 1) + ((w >> q) & 1)) % 4 for w in range(64)))) + self.v = sum(1 << i for i in (0, 1, 2, 4)) + self.R = self.intern(tuple(w ^ (self.v if (w & self.v).bit_count() & 1 else 0) + for w in range(64)), (0,) * 64) + self.Ebase = self.left(self.H[0], self.left(self.H[1], self.H[2])) + self.REbase = self.left(self.R, self.Ebase) + self.A = [self.left(H, self.left(self.R, H)) for H in self.H] + need(self.left(self.R, self.R) == self.identity, 'unpaired R is an exact involution') + need(self.left(self.R, self.Ebase) == self.left(self.Ebase, self.R), + 'R commutes the exact three-plane native base') + for H in self.H: + need(self.left(H, H) == self.identity, 'H=-i*N1 has exact square I') + self.accept_rays = [self.rays[self.Ebase][0], self.rays[self.REbase][0]] + + def intern(self, mapping, phases): + key = bytes(mapping) + bytes(phases) + old = self.ids.get(key) + if old is not None: + return old + index = len(self.ops) + self.ids[key] = index + self.ops.append((mapping, phases)) + phase = phases[0] + ray_key = bytes(mapping) + bytes((p - phase) % 4 for p in phases) + ray = self.ray_ids.setdefault(ray_key, len(self.ray_ids)) + self.rays.append((ray, phase)) + return index + + def left(self, a, b): + key = a, b + if key not in self.left_cache: + ap, az = self.ops[a] + bp, bz = self.ops[b] + self.left_cache[key] = self.intern(tuple(ap[bp[i]] for i in range(64)), + tuple((bz[i] + az[bp[i]]) % 4 for i in range(64))) + return self.left_cache[key] + + def left_entry(self, op, entry, phase=0): + out = {} + for g, z in entry.items(): + h = self.left(op, g) + a, b = rotate(z, phase) + c, d = out.get(h, (0, 0)) + if (a + c, b + d) == (0, 0): + out.pop(h, None) + else: + out[h] = a + c, b + d + return out + + @staticmethod + def add_entry(*entries): + out = {} + for entry, sign in entries: + for g, (a, b) in entry.items(): + c, d = out.get(g, (0, 0)) + z = c + sign * a, d + sign * b + if z == (0, 0): + out.pop(g, None) + else: + out[g] = z + return out + + def native(self, matrix, bank, primitive, plane, negative): + out = list(matrix) + op = self.H[plane] if primitive == 'N' else self.A[plane] + phase = (3 if negative else 1) if primitive == 'N' else (2 if negative else 0) + for col in range(2): + j = 2 * bank + col + out[j] = self.left_entry(op, matrix[j], phase) + return tuple(out) + + def singleton_obstruction(self, matrix): + # A nonaccepted tensor-base ray represented by a single exact + # Gaussian phase cannot vanish in any f residue class. + for entry in matrix: + rays = Counter(self.rays[g][0] for g in entry) + if any(count == 1 and ray not in self.accept_rays for ray, count in rays.items()): + return True + return False + + def routing(self, matrix): + a, b, c, d = matrix + Ra, Rb, Rc, Rd = [self.left_entry(self.R, e) for e in matrix] + return (self.add_entry((a, 1), (Ra, 1), (c, 1), (Rc, -1)), + self.add_entry((b, 1), (Rb, 1), (d, 1), (Rd, -1)), + self.add_entry((a, 1), (Ra, -1), (c, 1), (Rc, 1)), + self.add_entry((b, 1), (Rb, -1), (d, 1), (Rd, 1))) + + def completion(self, matrix, residue, routing_count): + out = [] + for entry in matrix: + folded = {} + for g, z in entry.items(): + ray, phase = self.rays[g] + a, b = rotate(z, phase * residue) + c, d = folded.get(ray, (0, 0)) + if (a + c, b + d) == (0, 0): + folded.pop(ray, None) + else: + folded[ray] = a + c, b + d + if any(ray not in self.accept_rays for ray in folded): + return None + # E3_f=-i*Ebase^tensor(f). Both accepted base rays have phase0. + out.append([rotate(folded.get(ray, (0, 0)), 1) for ray in self.accept_rays]) + den = 1 << routing_count + for epsilon in (-1, 1): + sector = [] + for zI, zR in out: + sector.append((zI[0] + epsilon * zR[0], zI[1] + epsilon * zR[1])) + for i in range(2): + for j in range(2): + value = (0, 0) + for h in range(2): + a, b = sector[2 * h + i] + c, d = sector[2 * h + j] + z = a * c + b * d, a * d - b * c + value = value[0] + z[0], value[1] + z[1] + need(value == ((den * den, 0) if i == j else (0, 0)), + 'every found R-sector outer completion is exactly unitary') + return dict(f_mod4=residue, common_dyadic_denominator=den, + entries_I_R_Gaussian_numerators=out, + inverse='Conjugate transpose the two I/R coefficient matrices. R is an actual Hermitian involution; lower by its projectors or literal elementary bank gates.') + + +def run(): + A = TensorBase() + initial = ({A.identity: (1, 0)}, {}, {}, {A.identity: (1, 0)}) + hits = {s: [] for s in range(4)} + counts = Counter() + all_residue_hits = [] + def visit(matrix, word, depth): + if depth == 5: + counts['native_words'] += 1 + if A.singleton_obstruction(matrix): + counts['singleton_ray_rejections'] += 1 + return + found = [] + for residue in range(4): + completion = A.completion(matrix, residue, 4) + if completion is not None: + counts['residue_completion_hits'] += 1 + found.append(completion) + if len(hits[residue]) < 3: + hits[residue].append(dict(queries=word, outer_completion=completion)) + if len(found) == 4: + counts['all_residue_word_hits'] += 1 + if len(all_residue_hits) < 3: + all_residue_hits.append(dict(queries=word, completions=found)) + return + for bank in range(2): + for primitive in ('N', 'A'): + for plane in range(3): + for negative in (False, True): + next_matrix = A.native(matrix, bank, primitive, plane, negative) + if depth < 4: + next_matrix = A.routing(next_matrix) + visit(next_matrix, word + [dict(bank=bank, primitive=primitive, plane=plane, + negative=negative)], depth + 1) + visit(initial, [], 0) + need(counts['native_words'] == 24 ** 5, 'every declared five-query primitive/axis/bank/unit pattern is covered') + # A real escape check: residual pattern 100 is sent to111 by this R. + w, v = 1 << 1, A.v + wp = w ^ v + residual = lambda z: [((z >> (2 * i)) ^ (z >> (2 * i + 1))) & 1 for i in range(3)] + need(residual(w) == [1, 0, 0] and residual(wp) == [1, 1, 1], 'R genuinely escapes the marked one-owner subspace') + # One-bit S=(1+i)I/2+(1-i)Z/2 is a true matrix identity, but its + # coefficientwise tensor lift is false at two bits on input11. + need(rotate((1, 0), 2) == (-1, 0), 'actual S tensor S gives -1 on11') + false_tensor_lift_on_11 = (1, 0) + need(false_tensor_lift_on_11 != (-1, 0), 'f1 linear relation is not accepted as an all-f tensor relation') + native = HERE.parent / 'native-frames' + return dict(status='PASS_EXACT_BOUNDED_UNPAIRED_REFLECTION_SCREEN', no_new_kappa=True, + target='diag(E3,E3), E3=N0*N1*N2, six native planes of stock across two banks; desired5H2 instead of6H2.', + native_words=counts['native_words'], residue_completion_hits=counts['residue_completion_hits'], + all_residue_word_hits=counts['all_residue_word_hits'], hits_by_f_mod4=hits, + singleton_ray_rejections=counts['singleton_ray_rejections'], + complete_word_hits=all_residue_hits, + reflection='R=P_A bitwise overf; A=I+vvT, v=(p0,q0,p1,p2). It is orthogonal, involutive, and commutes fullE3 exactly. TypedD^-1P_A D=P_A because three selected chunks arep and oneq.', + marked_escape=dict(input_X_character=w, output_X_character=wp, + input_residual_labels=residual(w), output_residual_labels=residual(wp)), + grammar='Exactly five unary queries, each chosen from +/-N_i and +/-A_i on all3planes/eitherbank, where A_i=N_i R N_i^-1 has independently admitted native rank2f and is charged ONCE. Exactly W(R) occurs between consecutive queries. Arbitrary outer GL2(Q(i)[R]) completion is accepted separately for eachf mod4. All24^5 patterns are covered; additional internal Z, other scalar bank phases, other reflections or general bitlinear ADDRESS words are outside this screen.', + fused_native_A='A_i,f=(H_i R H_i)^tensorf, with no outside i factor. Native worker independently supplies its single-rank2f literal query and monomial adapters; the group identity by itself does not establish this tariff.', + all_f_tensor_proof='On one bit per chunk H_i=-i*N_i,1 is the exact X-character monomial w->w xor{p_i,q_i} with phasei^(-w_pi+w_qi). For everyf, N_i,f=i*H_i^tensorf. R_f=R_1^tensorf. Matrix entries of the screened word are finite Gaussian dyadic sums of tensor powers of the represented base monomials. Equality after grouping exact monomial rays and theiri^(f mod4) phases is therefore an exact all-f identity; f1-only linear relations between distinct monomials are never accepted. A found completion uses only I,R and Gaussian dyadic scalars and is checked unitary in bothR sectors.', + necessity_for_this_finite_grammar='Distinct nonproportional base-operator vectors have linearly independent f-th tensor powers once f is sufficiently large: choose, for each vector, a product of linear forms annihilating every other vector. For each fixed fmod4 the same argument applies after absorbing Gaussian ray phases. Thus the ray-support failure is an all-f obstruction within this finite word grammar, even if the outer scalar coefficients are allowed to depend onf.', + negative_controls=['A genuine f1 matrix identity S=(1+i)I/2+(1-i)Z/2 fails its coefficientwise tensor lift on f2 input11: actual -1, false lift +1.', + 'The unpaired R sends one residual mark to three and is explicitly outside the marked-C invariant block.'], + group_model=dict(exact_base_monomials=len(A.ops), exact_base_rays=len(A.ray_ids), cached_left_products=len(A.left_cache), dimension=64), + scope='A zero-hit result is exhaustive only for this specified internal-routing grammar and its declared outer completions; it is not a global lower bound for full Pauli or arbitrary ADDRESS bridges.', + source_pins=[dict(path=str(native / name), sha256=hashlib.sha256((native / name).read_bytes()).hexdigest()) + for name in ['native_model.py', 'conjugated_reflection.py', 'CONJUGATED-REFLECTION.json']], + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest()) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = json.loads(json.dumps(run())) + path = HERE / 'UNPAIRED-REFLECTION-SCREEN.json' + if args.write: + path.write_text(json.dumps(out, sort_keys=True, indent=2) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved reflection screen differs') + print(out['status'], 'words', out['native_words'], 'all-f hits', out['all_residue_word_hits'], + 'residue hits', out['residue_completion_hits']) + + +if __name__ == '__main__': + main() diff --git a/research/one-query-endpoint-scan/source/q4-pauli-fusion/varied_reflection_screen.py b/research/one-query-endpoint-scan/source/q4-pauli-fusion/varied_reflection_screen.py new file mode 100644 index 0000000000..23b4b68f47 --- /dev/null +++ b/research/one-query-endpoint-scan/source/q4-pauli-fusion/varied_reflection_screen.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""A varied-route five-query all-f tensor screen, with fused native queries. + +Fixed banks alternate0,1,0,1,0. Routes are R0,R1,R2,R0, and query +choices include all nine Ad_Ni(Rj), each priced as one admitted H2. +The added full conjugate N0(R0 P2 R0)N0^-1 is also priced once. +Apache-2.0; substantial OpenAI Codex assistance. +""" +from pathlib import Path +from collections import Counter +import argparse +import hashlib +import json +from unpaired_reflection_screen import TensorBase, rotate, need + +HERE = Path(__file__).resolve().parent + + +class VariedBase(TensorBase): + def __init__(self): + super().__init__() + self.Rs = [] + for q in (1, 3, 5): + v = sum(1 << i for i in (0, 2, 4, q)) + self.Rs.append(self.intern(tuple(w ^ (v if (w & v).bit_count() & 1 else 0) + for w in range(64)), (0,) * 64)) + self.Ps = [] + for plane in (1, 2): + p = list(range(6)) + for j in range(2): + p[j], p[2 * plane + j] = p[2 * plane + j], p[j] + self.Ps.append(self.intern(tuple(sum(((w >> j) & 1) << p[j] for j in range(6)) + for w in range(64)), (0,) * 64)) + self.free = {self.identity} + todo = [self.identity] + generators = self.Rs + self.Ps + for old in todo: + for g in generators: + new = self.left(g, old) + if new not in self.free: + self.free.add(new) + todo.append(new) + need(len(self.free) < 10000, 'declared free group stays inside the bounded screen') + for g in self.free: + need(self.left(g, self.Ebase) == self.left(self.Ebase, g), + 'every accepted outer ADDRESS commutes full E3 exactly') + self.free = sorted(self.free) + self.accept = {} + for g in self.free: + target = self.left(g, self.Ebase) + ray, phase = self.rays[target] + need(phase == 0, 'accepted full-native ADDRESS rays have exact zero base phase') + need(ray not in self.accept, 'distinct ADDRESS completions remain distinct tensor rays') + self.accept[ray] = g + self.accept_rays = set(self.accept) + self.choices = [] + for i, H in enumerate(self.H): + for negative in (False, True): + self.choices.append(dict(kind='N', plane=i, negative=negative, operator=H, + scalar_phase=3 if negative else 1)) + for j, R in enumerate(self.Rs): + for i, H in enumerate(self.H): + A = self.left(H, self.left(R, H)) + for negative in (False, True): + self.choices.append(dict(kind='A', plane=i, reflection=j, negative=negative, + operator=A, scalar_phase=2 if negative else 0)) + RpR = self.left(self.Rs[0], self.left(self.Ps[1], self.Rs[0])) + B = self.left(self.H[0], self.left(RpR, self.H[0])) + for negative in (False, True): + self.choices.append(dict(kind='B_full_conjugate', plane=0, reflection=0, + ADDRESS_plane_swap=2, negative=negative, operator=B, + scalar_phase=2 if negative else 0)) + need(len(self.choices) == 26, 'the declared fused native alphabet has26 choices per fixed bank') + + def apply_query(self, matrix, bank, choice): + out = list(matrix) + for col in range(2): + j = 2 * bank + col + out[j] = self.left_entry(choice['operator'], matrix[j], choice['scalar_phase']) + return tuple(out) + + def route(self, matrix, R): + a, b, c, d = matrix + Ra, Rb, Rc, Rd = [self.left_entry(R, e) for e in matrix] + return (self.add_entry((a, 1), (Ra, 1), (c, 1), (Rc, -1)), + self.add_entry((b, 1), (Rb, 1), (d, 1), (Rd, -1)), + self.add_entry((a, 1), (Ra, -1), (c, 1), (Rc, 1)), + self.add_entry((b, 1), (Rb, -1), (d, 1), (Rd, 1))) + + def complete(self, matrix, residue): + entries = [] + for entry in matrix: + folded = {} + for g, z in entry.items(): + ray, phase = self.rays[g] + a, b = rotate(z, phase * residue) + c, d = folded.get(ray, (0, 0)) + value = a + c, b + d + if value == (0, 0): + folded.pop(ray, None) + else: + folded[ray] = value + if any(ray not in self.accept for ray in folded): + return None + entries.append({self.accept[ray]: rotate(z, 1) for ray, z in folded.items()}) + # B=E3^-1*candidate has dyadic Gaussian coefficients. The complete + # candidate and E3 are unitary, so B^-1=B^dagger. Verify that exact + # group-algebra identity, not merely one finite-dimensional image. + def inverse(g): + mapping, phase = self.ops[g] + need(not any(phase), 'free completion words are literal ADDRESS permutations') + p = [None] * 64 + for i, j in enumerate(mapping): + p[j] = i + return self.intern(tuple(p), (0,) * 64) + for i in range(2): + for j in range(2): + product = {} + for h in range(2): + for g, (a, b) in entries[2 * h + i].items(): + for k, (c, d) in entries[2 * h + j].items(): + op = self.left(inverse(g), k) + z = a * c + b * d, a * d - b * c + e, f = product.get(op, (0, 0)) + value = e + z[0], f + z[1] + if value == (0, 0): + product.pop(op, None) + else: + product[op] = value + need(product == ({self.identity: (256, 0)} if i == j else {}), + 'found full ADDRESS-group outer completion is unitary in the exact tensor group algebra') + return dict(f_mod4=residue, common_denominator=16, + entries=[[[g, list(z)] for g, z in sorted(entry.items())] for entry in entries], + inverse='Conjugate transpose and invert each displayed literal ADDRESS word.') + + +def run(): + A = VariedBase() + initial = ({A.identity: (1, 0)}, {}, {}, {A.identity: (1, 0)}) + routes = [0, 1, 2, 0] + banks = [0, 1, 0, 1, 0] + counts = Counter() + hits = {s: [] for s in range(4)} + all_hits = [] + def visit(matrix, word, depth): + if depth == 5: + counts['words'] += 1 + if A.singleton_obstruction(matrix): + counts['singleton_ray_rejections'] += 1 + return + found = [] + for residue in range(4): + completion = A.complete(matrix, residue) + if completion is not None: + counts['residue_hits'] += 1 + found.append(completion) + if len(hits[residue]) < 3: + hits[residue].append(dict(query_choice_indices=word, completion=completion)) + if len(found) == 4: + counts['all_residue_hits'] += 1 + if len(all_hits) < 3: + all_hits.append(dict(query_choice_indices=word, completions=found)) + return + for index, choice in enumerate(A.choices): + next_matrix = A.apply_query(matrix, banks[depth], choice) + if depth < 4: + next_matrix = A.route(next_matrix, A.Rs[routes[depth]]) + visit(next_matrix, word + [index], depth + 1) + visit(initial, [], 0) + need(counts['words'] == 26 ** 5, 'every declared varied-route fused-native word is covered') + return dict(status='PASS_EXACT_BOUNDED_VARIED_REFLECTION_SCREEN', no_new_kappa=True, + words=counts['words'], singleton_ray_rejections=counts['singleton_ray_rejections'], + residue_completion_hits=counts['residue_hits'], all_residue_word_hits=counts['all_residue_hits'], + hits_by_f_mod4=hits, complete_word_hits=all_hits, + target='diag(E3,E3), E3=N0*N1*N2; five rank2f native queries versus stock6 rank2f.', + bank_pattern=banks, routing_reflection_pattern=routes, + query_alphabet=A.choices, + exact_free_outer_ADDRESS_group_order=len(A.free), + free_outer_group_generators='Whole-plane swaps P01/P02 and the3 unpaired reflections Rj withvj=p0+p1+p2+qj.', + free_outer_group_operators=[dict(index=g, X_character_permutation=list(A.ops[g][0])) for g in A.free], + tensor_model=dict(base_dimension=64, exact_monomials=len(A.ops), exact_rays=len(A.ray_ids)), + all_f_proof='Uses the exact tensor-base and Gaussian phase folding of unpaired_reflection_screen.py. Every accepted endpoint is over the complete generated native-zero ADDRESS group, not a short palette. E3 commutes that group, so arbitrary left/right GL2 endpoints reduce to the tested right completion. Distinct tensor rays are not identified using f1 linear relations. Every admitted Aij and the full conjugateB is charged once using its independent physical native recipe.', + limits=['Fixed alternating bank pattern and fixed four-route sequence only; this is not all possible five-query words.', + 'Extra internal scalar bank phases, PauliZ routes, other ADDRESSs or additional route slots are outside the declared grammar.', + 'A positive group-algebra endpoint still needs its complete literal dyadic ADD/ADDRESS factorization before being priced as a caller.'], + producer_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + source_pins=[dict(path=str(HERE / 'unpaired_reflection_screen.py'), + sha256=hashlib.sha256((HERE / 'unpaired_reflection_screen.py').read_bytes()).hexdigest())]) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--write', action='store_true') + args = ap.parse_args() + out = json.loads(json.dumps(run())) + path = HERE / 'VARIED-REFLECTION-SCREEN.json' + if args.write: + path.write_text(json.dumps(out, sort_keys=True, indent=2) + '\n') + else: + need(json.loads(path.read_text()) == out, 'saved varied reflection screen differs') + print(out['status'], 'words', out['words'], 'all-f hits', out['all_residue_word_hits'], + 'residue hits', out['residue_completion_hits']) + + +if __name__ == '__main__': + main() diff --git a/research/one-query-endpoint-scan/source/vendor/clifford_exact.py b/research/one-query-endpoint-scan/source/vendor/clifford_exact.py new file mode 100644 index 0000000000..166841a037 --- /dev/null +++ b/research/one-query-endpoint-scan/source/vendor/clifford_exact.py @@ -0,0 +1,149 @@ +"""Small exact Gaussian-dyadic Clifford compiler, independent of gx internals. +Paulis use i^p X^x Z^z. State vectors use integer Gaussian numerators / 2^d. +The tableau is supplemented by a literal circuit, so global phases are kept. +""" +from dataclasses import dataclass + +def parity(x):return x.bit_count()&1 +def rank(rows): + p={} + for x in rows: + while x: + b=x.bit_length()-1 + if b not in p:p[b]=x;break + x^=p[b] + return len(p) +def transpose(rows,n):return tuple(sum(((rows[j]>>i)&1)<>j&1);a[j],a[k]=a[k],a[j] + for i in range(n): + if i!=j and a[i]>>j&1:a[i]^=a[j] + assert [r&((1<>n for r in a) +def basis_extend(cols,n): + out=[] + for x in list(cols)+[1<len(out):out.append(x) + assert len(out)==n + return tuple(out) +def nullspace(rows,n): + a=list(rows);p=[];k=0 + for j in range(n): + t=next((i for i in range(k,len(a)) if a[i]>>j&1),None) + if t is None:continue + a[t],a[k]=a[k],a[t] + for i in range(len(a)): + if i!=k and a[i]>>j&1:a[i]^=a[k] + p.append(j);k+=1 + return tuple((1<>j)&1)<>i&1:out=pmul(out,T[i]) + for i in range(n): + if z>>i&1:out=pmul(out,T[n+i]) + return out +def compose(A,B):return tuple(apply(A,p) for p in B) +def inverse(T): + n=len(T)//2;cols=[x|(z<>n;u,v,p=apply(T,(x,z,0));assert (u,v)==identity(n)[j][:2];out.append((x,z,(-p)%4)) + return tuple(out) +def qvalue(Q,alpha,x,n): + return (sum(alpha[i] for i in range(n) if x>>i&1)+2*sum(parity((Q[i]>>(i+1))&(x>>(i+1))) for i in range(n) if x>>i&1))%4 +def mul_i(a,p): + x,y=a;p%=4 + return [(x,y),(-y,x),(-x,-y),(y,-x)][p] +@dataclass +class Op: + n:int + tab:tuple + circuit:list + def then(self,b): + assert self.n==b.n + return Op(self.n,compose(b.tab,self.tab),self.circuit+b.circuit) + def adjoint(self): + circ=[] + for e in reversed(self.circuit): + if e[0]=='P':circ.append(('P',inv(e[1],self.n))) + elif e[0]=='D':circ.append(('D',e[1],tuple((-x)%4 for x in e[2]))) + elif e[0]=='C':circ.append(('C',e[1],-e[2])) + elif e[0]=='phase':circ.append(('phase',(-e[1])%4)) + else:circ.append(e) + return Op(self.n,inverse(self.tab),circ) + def zero_state(self,basis=0): + N=1<>i)&1 for i in range(n)) + assert all(alpha[i]%2==(Q[i]>>i)&1 for i in range(n)) + return Op(n,tuple([(1<>i&1 else 0,1<>i&1 else 0) for i in range(n)]),[('C',q,sgn)]) +def xgate(n,b):return Op(n,tuple([(1<>i)&1)) for i in range(n)]),[('X',b)]) +def fourier(n,axes=None): + out=ident(n) + for i in range(n) if axes is None else axes:out=out.then(cgate(n,1<len(selected):picks.append(j);selected.append(x) + assert len(picks)==r and all(x>>r==0 for x in Bcols) + Br=transpose(selected,r);Bi=inv(Br,r);Dr=transpose([Dcols[j]&((1<> i & 1) + for i in range(operator.n): + if x >> i & 1: + phase += 2 * ((rows[i] >> (i + 1)) & (x >> (i + 1))).bit_count() + result[x] = gaussian_unit(value, phase) + state = result + elif kind == 'C': + direction, sign = event[1:] + result = {} + for x, (a, b) in state.items(): + for y, value in ((x, (a-sign*b, b+sign*a)), + (x ^ direction, (a+sign*b, b-sign*a))): + u, v = result.get(y, (0, 0)) + result[y] = u + value[0], v + value[1] + state = {x: value for x, value in result.items() if value != (0, 0)} + denominator += 1 + else: + raise ValueError(event) + while denominator and all(not ((a | b) & 1) for a, b in state.values()): + state = {x: (a // 2, b // 2) for x, (a, b) in state.items()} + denominator -= 1 + return state, denominator + + +def standard_product(ce, *operators): + """Return operators[0] ... operators[-1] in conventional product order.""" + result = ce.ident(operators[0].n) + for operator in reversed(operators): + result = result.then(operator) + return result + + +def canonical_predecessor(): + for name, expected in PINS.items(): + need(hashlib.sha256((OLD / name).read_bytes()).hexdigest() == expected, 'frozen source pin: ' + name) + spec = importlib.util.spec_from_file_location('stabilizer_frozen_endpoint', OLD / 'canonical_endpoints.py') + module = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = module + spec.loader.exec_module(module) + need(hashlib.sha256(module.CP.read_bytes()).hexdigest() == '2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962', 'native compiler pin') + return module + + +def deliberate_monomial(ce, n, cut, variant): + """Dense pair stabilizer: nonorthogonal GL2, fresh GL, and cross chirps. + + This is one prescribed construction, not a seed or search. The common + address matrix is A=[[0,1],[1,1]], and Q_CC=I+A^-T A^-1=[[1,1],[1,0]]. + """ + rows = [1 << i for i in range(n)] + rows[:2] = [2, 3] + fresh = list(range(2, n)) + # Swap completed and future directions, then mix every fresh direction. + past = 2 + 5 * (cut + 1) - 1 + future = 2 + 5 * (cut + 1) + if future < n: + rows[past], rows[future] = rows[future], rows[past] + for index in range(len(fresh) - 1): + a, b = fresh[index], fresh[index + 1] + rows[a] ^= rows[b] + rows[0] ^= sum(1 << i for i in fresh if (i + variant) % 2 == 0) + rows[1] ^= sum(1 << i for i in fresh if (i + variant) % 3 == 0) + quadratic = [3, 1] + [0] * (n - 2) + for i in fresh: + j = (i + variant) % 2 + quadratic[i] ^= 1 << j + quadratic[j] ^= 1 << i + if (i + variant) % 3 == 1: + quadratic[i] ^= 1 << i + for a, b in zip(fresh[::2], fresh[1::2]): + quadratic[a] ^= 1 << b + quadratic[b] ^= 1 << a + operator = ce.perm(n, rows).then(ce.diag(n, quadratic)).then(ce.xgate(n, (1 << (2 + variant % (n - 2))) | 1)) + common = ce.cgate(n, 1).adjoint().then(ce.cgate(n, 2)) + other = standard_product(ce, common, operator, common.adjoint()) + need(native_rank(operator) == native_rank(other) == 0, 'prescribed full pair stabilizer admission') + # Sparse complete-column phase witness for the actual rank-zero conjugate. + state, den = sparse_column(other) + need(den == 0 and len(state) == 1 and next(iter(state.values())) in ((1, 0), (0, 1), (-1, 0), (0, -1)), 'actual second-cut monomial phase') + return operator, {'address_rows': rows, 'quadratic_rows': quadratic, 'second_front_zero_column': [list(state.items()), den]} + + +def verify_free_word(): + """Independent group-ring replay of the frozen arbitrary-input B1 word.""" + data = json.loads((OLD / 'NONCOMMON-B1.json').read_text()) + + def reduce(word): + result = [] + for symbol in word: + if result and result[-1] == -symbol: + result.pop() + else: + result.append(symbol) + return tuple(result) + + rows = [{((), 0): 1}, {((), 1): 1}] + for gate in data['word']: + if gate['op'] == 'LEFT': + rows[gate['dst']] = {(reduce(tuple(gate['word']) + word), column): coefficient for (word, column), coefficient in rows[gate['dst']].items()} + elif gate['op'] == 'ADD': + destination = dict(rows[gate['dst']]) + for key, coefficient in rows[gate['src']].items(): + destination[key] = destination.get(key, 0) + gate['q'] * coefficient + if destination[key] == 0: + del destination[key] + rows[gate['dst']] = destination + elif gate['op'] == 'EXCHANGE': + rows = [rows[1], {key: -coefficient for key, coefficient in rows[0].items()}] + else: + raise ValueError(gate) + endpoint = (-3, 5, -2, 4, -1) + need(rows == [{(endpoint, 0): 1}, {(endpoint, 1): 1}], 'independent arbitrary-column group-ring identity') + return {'input_columns': 2, 'free_invertible_operators': 5, 'endpoint': list(endpoint)} + + +def run(): + old = canonical_predecessor() + ce = old.ce + records, phase_cases, controls = [], [], [] + for group in range(3): + for coordinate, p in enumerate(old.bus['groups7'][group]): + q = old.bus['groups7'][(group + 1) % 3][coordinate] + r = old.bus['groups7'][(group + 2) % 3][coordinate] + chart = ce.perm(7, ce.transpose(old.completion(p, q), 7)) + if group == 2: + pre = old.build(7, old.winner[p]['pre_events']) + else: + direction = q ^ r + pre = ce.perm(7, [(1 << i) ^ (direction if direction >> i & 1 else 0) for i in range(7)]) + canonical_pre, _ = ce.monomial(chart.then(pre).then(chart.adjoint())) + local_p = canonical_pre.adjoint() + local_fresh = ce.fourier(7, range(2, 7)) + local_common = ce.cgate(7, 1).then(ce.cgate(7, 2).adjoint()) + first = standard_product(ce, local_fresh, local_p, local_common) + rank_first = native_rank(first) + need(rank_first == (3 if group == 2 else 5), 'actual fixed first-factor native rank') + # Complete phase check against the pinned compiler's literal lowering. + recipe, lowered = ce.lower_child(first) + need(recipe['rank'] == rank_first and first.tab == lowered.tab, 'native lowering signed tableau') + need(sparse_column(first) == sparse_column(lowered), 'independent local global phase') + cases = [] + for length in (1, 3, 5, 9): + n = 2 + 5 * length + cp, cq = ce.cgate(n, 1), ce.cgate(n, 2) + common = cp.then(cq.adjoint()) + fresh = [ce.fourier(n, range(2 + 5 * stage, 7 + 5 * stage)) for stage in range(length)] + ps = [old.embed(n, canonical_pre.circuit, [0, 1] + list(range(2 + 5 * stage, 7 + 5 * stage))).adjoint() for stage in range(length)] + qtotal, baseline, fpast, factored = ps[0], ps[0], fresh[0], standard_product(ce, fresh[0], ps[0], common) + monomials = [] + for stage in range(1, length): + monomial, _ = deliberate_monomial(ce, n, stage - 1, stage) + monomials.append(monomial) + insertion = standard_product(ce, fpast.adjoint(), monomial, fpast) + qtotal = standard_product(ce, ps[stage], insertion, qtotal) + baseline = standard_product(ce, ps[stage], baseline) + fpast = standard_product(ce, fresh[stage], fpast) + factor = standard_product(ce, fresh[stage], ps[stage]) + need(native_rank(factor) == 5, 'later factor native rank') + factored = standard_product(ce, factor, monomial, factored) + original = standard_product(ce, fpast, qtotal, common) + need(original.tab == factored.tab, 'exact signed tableau of telescoping factorization') + # Independent columns/multiplication agree with exact compiler. + independent = binary_product(binary_tableau(fpast), binary_product(binary_tableau(qtotal), binary_tableau(common))) + need(independent == binary_tableau(original), 'independent symplectic endpoint multiplication') + rank_y = native_rank(original) + bound = 5 * (length - 1) + rank_first + need(rank_y <= bound < n, 'universal theorem bound on deliberate insertion') + baseline_y = standard_product(ce, fpast, baseline, common) + need(native_rank(baseline_y) == bound, 'identity insertion attains universal Y bound') + fx = standard_product(ce, ce.fourier(n), ce.xgate(n, 1), qtotal) + rank_x = native_rank(fx) + # At genuine B1 size17, independently compare full columns for + # a representative A port and C port; this fixes global phase. + if length == 3 and coordinate == 0 and group in (0, 2): + original_state = sparse_column(original) + need(original_state == sparse_column(factored), 'global B1 exact Gaussian column') + phase_wrong = factored.then(ce.Op(n, ce.identity(n), [('phase', 1)])) + need(phase_wrong.tab == original.tab and sparse_column(phase_wrong) != original_state, 'global-phase omission control') + phase_cases.append({'group': group, 'p': p, 'n': n, 'output_support': len(original_state[0]), 'denominator_depth': original_state[1]}) + cases.append({'L': length, 'm': n, 'X_native_rank': rank_x, 'Y_native_rank': rank_y, 'Y_rank_upper_bound': bound, 'identity_insertion_Y_native_rank': native_rank(baseline_y), 'Y_deficit_lower_bound': n - bound}) + records.append({'group': group, 'coordinate': coordinate, 'p': p, 'q': q, 'first_factor_rank': rank_first, 'cases': cases}) + # An undressed logical ADDRESS swap has a real hidden native query. + n = 4 + cp, cq, past = ce.cgate(n, 1), ce.cgate(n, 2), ce.cgate(n, 4) + dx = standard_product(ce, cp, past) + swap = ce.perm(n, [1, 2, 8, 4]) + dressed = standard_product(ce, dx.adjoint(), swap, dx) + need(native_rank(standard_product(ce, dx, dressed, dx.adjoint())) == 0, 'dressed swap admitted') + hidden = native_rank(standard_product(ce, dx, swap, dx.adjoint())) + need(hidden == 2, 'undressed swap admission control') + common = standard_product(ce, cq, cp.adjoint()) + no_chirp = ce.perm(n, [2, 3, 4, 8]) + need(native_rank(standard_product(ce, common, no_chirp, common.adjoint())) > 0, 'common chirp omission control') + wrong_inverse = standard_product(ce, past, swap, past) + right_inverse = standard_product(ce, past.adjoint(), swap, past) + need(wrong_inverse.tab != right_inverse.tab, 'positive/adjoint past-frame control') + controls.extend(['undressed_swap_costs_rank2', 'common_chirp_omission_breaks_second_front', 'past_frame_inverse_sign_is_essential', 'global_phase_i_rejected_on_two_B1_ports']) + return { + 'status': 'PASS_FULL_MONOMIAL_INSERTION_Y_RANK_OBSTRUCTION_NO_NEW_KAPPA', + 'scientific_pin': PIN, + 'sources_sha256': PINS, + 'source_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'free_word': verify_free_word(), + 'theorem': {'C_Y_rank_upper': '5L-2 = m-4', 'AB_Y_rank_upper': '5L = m-2', 'm': '2+5L', 'quantifiers': 'Every L>=1; every locally admitted monomial pre_s on common2 plus own fresh5 with fixed first-factor ranks3/5; every insertion whose physical X-cut pullback is any invertible monomial. Second-front admission is unnecessary for the upper bound. Arbitrary permutations and diagonal nonzero phases, including non-Clifford monomials, are covered by the row-support proof.'}, + 'factorization': 'F_all P_last (F_past^-1 M_last-1 F_past) ... P_1 (F_0^-1 M_0 F_0) P_0 R = (F_last P_last) M_last-1 ... (F_1 P_1) M_0 (F_0 P_0 R)', + 'records': records, + 'independent_global_phase_cases': phase_cases, + 'defect_controls': controls, + 'all_size': 'Tensor columnwise over f>=1: each later factor has row support2^(5f), first factor2^(3f) C or2^(5f) A/B; monomials preserve support. Thus terminal Y has row support <=2^((m-4)f) C or2^((m-2)f) A/B and cannot be a rank-mf native child, even with arbitrary input values.', + 'cost_boundary': {'OPEN_local_histogram': {'1': 8, '2': 40, '3': 16}, 'OPEN_local_rank_mass': 136, 'ordinary_helpers': 0, 'private_fields': 0, 'isolated_unary_completion_rank_lower_bound_per_twelve_port_Y_bank': 32, 'insertion_scans': 'All actual monomial address/phase scans remain paid; zero native rank does not mean zero work.'}, + 'limits': ['No arbitrary multibank insertion, changed scalar word, changed entrance code, overlapping local fresh supports, or different raw local boundary is excluded.', 'The proof does not calculate an optimal paid completion word, owner allocation, all-size rounded precision, physical tape controller, or positive conditional kappa.', 'This is a written all-parameter proof with finite exact operator checks, not formal-kernel verification.'], + 'attribution': 'Uses frozen source-carrier/common-F normalizers and canonical endpoint charts from the2026-10-18 run; predecessor complex and algebra lanes plus root own those constructions. This lane supplies the exact telescoping argument, full arbitrary-monomial support bound, independent symplectic arithmetic and Gaussian phase evaluator.' + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write', action='store_true') + args = parser.parse_args() + output = json.loads(json.dumps(run())) + target = HERE / 'FULL-STABILIZER-BOUND.json' + if args.write: + target.write_text(json.dumps(output, indent=2, sort_keys=True) + '\n') + else: + need(json.loads(target.read_bytes()) == output, 'stored exact receipt mismatch') + print(output['status']) + print('12 ports x L1/3/5/9; arbitrary-monomial proof;2 exact n17 phase checks;4 defect controls') + + +if __name__ == '__main__': + main() diff --git a/research/one-query-endpoint-scan/verify.py b/research/one-query-endpoint-scan/verify.py new file mode 100644 index 0000000000..d1ae9e0126 --- /dev/null +++ b/research/one-query-endpoint-scan/verify.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python3 +"""Exact caller replay. Ross Richardson; substantial OpenAI Codex assistance. + +Apache-2.0. Immutable predecessor implementations are compiled from the same +bytes authenticated below, with optimize=0 to preserve historical assertions. +This direct verifier needs Python's standard library, no Git and no network. +""" +from pathlib import Path +from fractions import Fraction +from collections import Counter +import copy +import hashlib +import importlib +import importlib.abc +import importlib.util +import json +import sys + +sys.dont_write_bytecode=True +ROOT=Path(__file__).resolve().parent +META=json.loads((ROOT/'BINDINGS.json').read_bytes()) +PINS={row['path']:row for row in META['files']} +def need(condition,message): + if not condition:raise ValueError(message) +need(len(PINS)==len(META['files']),'duplicate retained-source path') +def checked(relative,raw=None): + row=PINS[relative];path=ROOT/relative + need(path.resolve()==path,'retained source must not be a symlink') + if raw is None:raw=path.read_bytes() + need(hashlib.sha256(raw).hexdigest()==row['sha256'],'retained source hash: '+relative) + return raw +for relative in PINS:checked(relative) + +def rejection(action,needle): + try:action() + except ValueError as error: + need(needle in str(error),'wrong rejecting predicate: '+str(error)) + else:raise ValueError('negative control unexpectedly accepted: '+needle) + +# Positive and negative source-binding controls use real source bytes. The +# loader below has no bytecode-cache path, including for dynamic source loads. +first=next(p for p in PINS if p.endswith('.py')) +need(checked(first,checked(first))==checked(first),'identical source positive control') +rejection(lambda:checked(first,checked(first)+b'\n# altered source\n'),'retained source hash') +MODULES={} +for relative in PINS: + if relative.startswith('source/') and relative.endswith('.py'): + stem=Path(relative).stem + need(stem not in MODULES,'ambiguous retained module '+stem) + MODULES[stem]=relative +class ByteLoader(importlib.abc.Loader): + def __init__(self,relative):self.relative=relative + def create_module(self,spec):return None + def exec_module(self,module): + raw=checked(self.relative) + exec(compile(raw,str(ROOT/self.relative),'exec',dont_inherit=True,optimize=0),module.__dict__) +class ByteFinder(importlib.abc.MetaPathFinder): + def find_spec(self,fullname,path=None,target=None): + if fullname in MODULES: + relative=MODULES[fullname] + return ORIGINAL_SPEC(fullname,str(ROOT/relative),loader=ByteLoader(relative)) +ORIGINAL_SPEC=importlib.util.spec_from_file_location +def bound_spec(name,location,*args,**kwargs): + path=Path(location).resolve() + if path.is_relative_to(ROOT): + relative=str(path.relative_to(ROOT)) + need(relative in PINS,'undeclared dynamic source '+relative) + return ORIGINAL_SPEC(name,str(path),loader=ByteLoader(relative)) + return ORIGINAL_SPEC(name,location,*args,**kwargs) +importlib.util.spec_from_file_location=bound_spec +sys.meta_path.insert(0,ByteFinder()) +def module(name):return importlib.import_module(name) +def data(relative):return json.loads(checked('source/'+relative)) +def source_path(original): + candidates=[p for p,row in PINS.items() if p.startswith('source/') and (row['origin']==original or row['origin'].endswith('/'+original))] + need(len(candidates)==1,'one retained original source for '+original) + return ROOT/candidates[0] + +# Receipts contain original absolute provenance paths. All retained bytes are +# separately checked above. These explicitly enumerated metadata fields are +# omitted ONLY when comparing replay's mathematical body to its frozen receipt. +PROVENANCE={'sources','source_pins','producer_sha256','helper_sha256', + 'native_model_sha256','reflection_source_sha256','source_path','source_sha256', + 'path','witness','witness_sha256'} +def body(value): + if isinstance(value,dict):return {str(k):body(v) for k,v in value.items() if k not in PROVENANCE} + if isinstance(value,(list,tuple)):return [body(v) for v in value] + return value +def difference(a,b,path='root'): + if type(a)!=type(b):return path+': type mismatch' + if isinstance(a,dict): + if a.keys()!=b.keys():return path+': keys '+str(set(a)^set(b)) + for k in a: + if a[k]!=b[k]:return difference(a[k],b[k],path+'.'+k) + elif isinstance(a,list): + if len(a)!=len(b):return path+': lengths '+str((len(a),len(b))) + for i,(x,y) in enumerate(zip(a,b)): + if x!=y:return difference(x,y,path+'['+str(i)+']') + elif a!=b:return path+': '+repr(a)[:150]+' != '+repr(b)[:150] + return path +RESULTS=[] +def replay(name,function,receipt): + actual=json.loads(json.dumps(getattr(module(name),function)())) + expected=data(receipt) + aa,bb=body(actual),body(expected) + need(aa==bb,'mathematical receipt mismatch '+receipt+' '+difference(aa,bb)) + RESULTS.append({'entry':name+'.'+function,'status':actual['status'],'mathematical_receipt':receipt}) + print('PASS_REPLAY',name,function,flush=True) + return actual + +result=replay('one_query_endpoint_obstruction','run','q4-pauli-fusion/ONE-QUERY-ENDPOINT-OBSTRUCTION.json') +op=module('one_query_endpoint_obstruction');A=module('reflection_route_pruned').EnlargedBase(True) +native=op.physical_certificate(A,A.H[0]);mono=op.physical_certificate(A,A.Rs[0]) +need(native['column_support_histogram']=={4:64} and mono['column_support_histogram']=={1:64},'native/monomial positive distinction') +def native_contract(c): + need(c['column_support_histogram']=={4:64} and c['maximum_entry_squared_modulus']=='1/4','actual native support/amplitude contract') +native_contract(native) +rejection(lambda:native_contract(mono),'actual native support/amplitude contract') +# A support threshold with a missing factor would incorrectly admit the one- +# coordinate input. Test the exact actual native column as a sharp fixture. +need(4==4**1 and 4>1,'sharp support uncertainty product') +for f in range(1,33): + need((1<<(2*f))==4**f and (2*f-1)<2*f,'exact growing ADD threshold') +# The helper proof needs the declared w<=M restriction. A larger queried +# helper can remove the dimension contradiction; it is an explicit boundary. +M=64;K=128 +need(all(2*M+K-w>K for w in range(1,M+1)),'same-or-smaller queried helper dimension') +need(2*M+K-(2*M)==K,'larger queried width escapes this dimension argument') +archives=[] +for filename,expected in [('UNPAIRED-REFLECTION-SCREEN.json',24**5),('VARIED-REFLECTION-SCREEN.json',26**5),('DUAL-REFLECTION-SCREEN.json',26**5)]: + x=data('q4-pauli-fusion/'+filename) + archives.append(dict(file=filename,status=x['status'],declared_five_query_space=expected,reexecuted=False)) +RESULTS.append(dict(entry='endpoint_controls_and_historical_screens',native_mislabel_rejected=True,helper_width_boundary=True,historical_screens=archives,limits='The archived five-query search receipts are retained and hashed; these large searches are not rerun by this registered command.')) +print('PASS_ENDPOINT_CONTROLS archived five-query screens retained, not rerun',flush=True) + +report=dict(status='PASS_PORTABLE_CALLER_PACKAGE',claims=META['claims'],no_new_kappa=True, + retained_files=len(PINS),mathematical_checks=RESULTS,source_bytes_compiled=True, + historical_assertions_enabled=True,source_mutation_rejected=True, + limits=['Written all-parameter proofs, finite exact replays and source integrity are distinct.', + 'No formal-kernel multiplication proof, physical supplier admission or selected frontier change.']) +if len(sys.argv)>1: + need(len(sys.argv)==2 and sys.argv[1]=='--json','only --json is supported') + print(json.dumps(report,indent=2,sort_keys=True)) +else:print(report['status'],','.join(report['claims']),'no_new_kappa=true',flush=True)