diff --git a/research/clean-query-rank-optimum/LICENSE b/research/clean-query-rank-optimum/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/clean-query-rank-optimum/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/clean-query-rank-optimum/NOTICE b/research/clean-query-rank-optimum/NOTICE new file mode 100644 index 0000000000..723763712a --- /dev/null +++ b/research/clean-query-rank-optimum/NOTICE @@ -0,0 +1,14 @@ +Prepared for ToikY with substantial source-aware OpenAI Codex assistance. +New proof/certificate code and text: Apache-2.0; repository LICENSE included. + +Retained exact mathematical source prose: Nick Petalas, PR6800, +restored-dirty-query-capacity, headc94197e40c9e8a25f643d776160659871e5ce9ac; +ToikY with OpenAI Codex assistance, PR6808, clean-two-helper-query, +head518351a389e32e2ccdf0a1ca55580e9c60d65492. Original source notices retained. +Source6800's projection Gram/rank method and inequality are credited prior +work; source6808's rank8 construction/helper minimum are not new here. + +Retain Josie Elliston6138, Nick Petalas6122, Cinna Davis, Ali Romman5617, +Matarener6114 and the distinct5007/5857/1974/2027 lineage and all notices +in the retained sources. Rank factorization, fixed-subspace transport, +rank-nullity and dual-number normalization are classical. diff --git a/research/clean-query-rank-optimum/PROOF.md b/research/clean-query-rank-optimum/PROOF.md new file mode 100644 index 0000000000..877bf597a8 --- /dev/null +++ b/research/clean-query-rank-optimum/PROOF.md @@ -0,0 +1,177 @@ +# Eight is the least paid rank for the four-call clean six-target problem + +## 1. Exact scope and credited attainment + +Let $K$ be any field of characteristic two and let +$\mathcal A=K[Q]/(Q^2-1)$, with $Q$ a formal central involution. +There are six public coordinates and any finite number $h\geq0$ of +zero-initialized helpers. Free gates are arbitrary constant matrices in +$\operatorname{GL}_{6+h}(K)$. Paid gates are $I+QN_i$, where $N_i$ is a +constant matrix on the **entire** public-plus-helper space, +$N_i^2=0$, and $r_i=\operatorname{rank}N_i\leq2$. +At most four paid gates are allowed. The required endpoint is precisely + +\[ + W(x,0)=(Qx,0)\qquad\text{for every }x\in\mathcal A^6. +\] + +Every such word has total paid rank $S=\sum_i r_i\geq8$. +Consequently any feasible word under the stated caps has exactly four +rank-two paid calls. The construction of +[PR6808](https://github.com/CrocSwap/integer-mult-bounds/pull/6808), +at head 518351a389e32e2ccdf0a1ca55580e9c60d65492, attains $S=8$ +with two clean helpers. Thus eight is the minimum total paid rank, +allowing any finite clean workspace, in this at-most-four-call model. +The attaining construction and its minimum-helper theorem are credited, +not reconstructed or replayed here. + +The method is the classical full-rank factorization and $UV/VU$ fixed-space +argument used in Nick Petalas's +[PR6800, section 3](https://github.com/petalas/integer-mult-bounds/blob/c94197e40c9e8a25f643d776160659871e5ce9ac/research/restored-dirty-query-capacity/PROOF.md). +Its projection case already gives $r_i\leq S-n$. The point checked here is +that the same needed inequality survives the weaker clean public-column +promise, without assuming the normalized matrix is a projection. The +retained source manifest governs the exact predecessor paths and bytes. + +## 2. Normalize the word without losing helper columns + +Put $\varepsilon=Q+1$. In characteristic two, +$\mathcal A=K[\varepsilon]/(\varepsilon^2)$, with $1,\varepsilon$ +linearly independent over $K$. For every permitted paid term, + +\[ + I+QN_i=(I+N_i)(I+\varepsilon N_i). +\] + +The constant factor $I+N_i$ is invertible. Moving all constant factors and +free gates to the left conjugates the $N_i$ by constant invertible matrices. +After relabeling these conjugates, the full word is + +\[ + W=C(I+\varepsilon M),\qquad + M=\sum_i N_i,\qquad N_i^2=0,\quad + \operatorname{rank}N_i=r_i,\quad C\in\operatorname{GL}_{6+h}(K). + \tag{1} +\] + +Products of two $\varepsilon$ terms vanish; no commutation of the $N_i$ +is needed. All matrices in (1) still act on all $6+h$ coordinates. + +Let $P=K^6\oplus0_h$ be the public subspace. Compare the two formal +coefficients of the clean endpoint on $p\in P$. They give + +\[ + Cp=p,\qquad CMp=p. +\] + +Since $C$ fixes $P$ pointwise, so does $C^{-1}$. Therefore + +\[ + Mp=p\quad(p\in P). \tag{2} +\] + +This does not say $C=I$ on the helper columns, nor that $M^2=M$. +In public/helper blocks it only says +$M=\begin{pmatrix}I_6&B\\0&D\end{pmatrix}$ for unspecified $B,D$. +The proof below retains them. Evaluating only $Q=1$, or replacing these +columns by zero, would not justify (2) or the desired formal endpoint. + +## 3. The fixed-subspace rank lemma + +The following lemma holds over **any** field, with no characteristic +restriction. Let $H$ be a finite-dimensional vector space, let +$N_i\in\operatorname{End}(H)$ be square-zero, and suppose +$M=\sum_iN_i$ fixes pointwise a subspace $P\subset H$ of dimension $d$. +Write $r_i=\operatorname{rank}N_i$ and $S=\sum_i r_i$. Then + +\[ + S\geq d+\max_i r_i. \tag{3} +\] + +To prove it, factor each nonzero term through $L_i=K^{r_i}$ as +$N_i=U_iV_i$, with $U_i:L_i\to H$ injective and +$V_i:H\to L_i$ surjective. Square-zero gives $V_iU_i=0$: +for any $w=V_ix$, the equality +$U_i(V_iU_i)w=N_i^2x=0$ and injectivity of $U_i$ imply this claim. +Zero terms can be omitted. + +Set $L=\bigoplus_iL_i$, so $\dim L=S$, and concatenate the maps as + +\[ + U:L\to H,\qquad V:H\to L,\qquad UV=M,\qquad E=VU. +\] + +Because $UVp=p$ on $P$, the restriction $V|_P$ is injective: +$Vp=0$ would imply $p=UVp=0$. Moreover + +\[ + E(Vp)=VUVp=Vp. +\] + +Thus the fixed space of $E$ contains $V(P)$ of dimension $d$. +Rank-nullity implies +$\operatorname{rank}(I_L-E)\leq S-d$. +On the other hand its call-diagonal block on $L_i$ is +$I_{r_i}-V_iU_i=I_{r_i}$. A submatrix cannot have larger rank than the +full matrix, so $\operatorname{rank}(I_L-E)\geq r_i$ for each $i$. +Combining the two inequalities proves (3). + +Only an inclusion in the fixed space is used. The argument neither +identifies its entire fixed space nor imposes a polynomial identity on +$E$ or $M$. It is consequently valid for arbitrary helper dimension and +arbitrary helper columns. + +## 4. Apply the lemma to the four-call problem + +Apply (3) to (1)--(2), with $d=6$. A feasible word has positive total +rank. Pad with zero-rank terms to four positions if necessary. +The largest of these four ranks is at least $S/4$, so + +\[ + S\geq6+\max_i r_i\geq6+S/4. +\] + +Hence $S\geq8$. The rank caps also give $S\leq4\cdot2=8$. +Equality forces four nonzero calls, each of rank two. Together with the +credited PR6808 word this proves the exact optimum asserted in section 1. +No finite matrix experiment or census is needed for this universal lower +bound. + +The at-most-four-call hypothesis is essential to this deduction. +It is not an optimum over unrestricted call counts, a classification +for other public dimensions, or a reproof of the minimum-helper result. +The factorization lemma itself is field-independent; the formal-query +normalization and application here require characteristic two. + +In particular, removing the four-call cap already allows a credited +smaller-total-rank word. PR6800's theorem, using the workspace-free +attainment of Josie Elliston6138, applies at $n=6$, $k=7$, $r=1$: +$m_7=6$ and $6+\lceil6/6\rceil=7$. It supplies seven rank-one calls +with no workspace and total paid rank seven. That endpoint also satisfies +the clean promise, and unused zero helpers can be appended. Thus a +rank-eight lower bound without the four-call restriction would be false; +this is a known predecessor boundary, not a new construction or an +unresolved claim about unrestricted calls. No such word is replayed here. + +## 5. Evidence, lineage, and remaining obligations + +This is a source-aware written proof. The coordinator supplied the proposed +fixed-space extension before this draft, and the author had prior exposure +to PR6800 and PR6808. It is not blind discovery, human acceptance, or a +formal-kernel certificate. Any separately reported finite checks must +state their observed domains and do not substitute for the quantified +argument above. No predecessor program, construction, matrix experiment, +or checker was executed by this proof role. + +Nick Petalas6800 supplies the normalization, projection Gram-complement +method, and clean-versus-dirty boundary; ToikY/Codex6808 supplies the +four-rank-two clean word and its helper theorem. Josie Elliston6138, +Nick Petalas6122, Cinna Davis's simplex/controller line, Ali Romman5617, +and Matarener6114 retain the lineage credited by those sources. + +Paid rank here is an abstract query cost. Preparation and ownership of +the zero helpers, implementation and pricing of free bases, native +alignment and chronology, precision, cleanup/restoration outside the +stated endpoint, and a complete physical supplier invoice remain open. +No selected-frontier, multiplication exponent, or all-five-assumptions +admission follows. diff --git a/research/clean-query-rank-optimum/README.md b/research/clean-query-rank-optimum/README.md new file mode 100644 index 0000000000..c45fa0dc61 --- /dev/null +++ b/research/clean-query-rank-optimum/README.md @@ -0,0 +1,90 @@ +# Exact paid-rank optimum for the fixed four-call clean query problem + +For any characteristic-two field K, formal central Q with Q²=1, six public +roles and any finite number of zero-initialized helpers returned zero, the +least total paid rank is **eight** when at most four square-zero paid calls +of whole-matrix rank at most2 are allowed. Free bases are arbitrary constant +invertible matrices. The complete clean columns must satisfy +W(x,0)=(Qx,0) for every x over K[Q]/(Q²−1). Old helper-value columns remain +unspecified; they are not silently restored or erased. + +The new contribution is the missing lower-bound implication. Own excluded +[PR6808](https://github.com/CrocSwap/integer-mult-bounds/pull/6808) already +supplies the four-rank-two/two-helper attaining word and the minimum helper +count. Those are cited attainment facts, not reconstructed, replayed or +claimed again. The four-call cap is essential: the credited PR6800/6138 theorem already gives six targets in seven rank-one calls with no helpers, total rank seven. That word also meets the clean contract; it is cited, not replayed. + +The method and projection-case inequality are credited to Nick Petalas +[PR6800](https://github.com/CrocSwap/integer-mult-bounds/pull/6800), section3. +That source requires the complete restored-DIRTY endpoint, producing a +projection. We extend only the needed rank argument to a matrix which fixes +the productive subspace. No new rank-factorization invariant is claimed. + +## Written argument + +The actual paid alphabet is I+Q N with N²=0. Put epsilon=1+Q and prove +I+QN=(I+N)(I+epsilon N), with I+N a legal constant free basis. +After absorbing/conjugating constants, W=C(I+epsilon M), M=sum N_i, +with all ranks/square-zero properties preserved on every role. The exact +clean columns give C|P=I and (CM)|P=I, hence M|P=I. They do not give M²=M +or constrain its other helper columns. + +Factor N_i=U_i V_i through its full rank r_i; square-zero gives V_i U_i=0. +Stack U,V, write E=VU on a space of dimension S=sum r_i. The map V is +injective on P and E fixes V(P), so rank(I−E)<=S−dimP. Every call-diagonal +block of I−E is I_(r_i), giving rank(I−E)>=max r_i. Thus +S>=dimP+max r_i. With six targets and at most four calls, +S>=6+S/4, hence S>=8. The caps give S<=8, forcing exactly four rank-two calls. +The field-independent lemma and characteristic-two query application are +separate in [PROOF.md](PROOF.md). The proof retains arbitrary finite helper +dimension and the complete allowed helper-column contract. + +## Evidence and reproduction + +The first root-controlled diagnostic passed in 0.678 seconds with 21.672MiB maximum RSS under CPython3.12.14. It authenticates four retained exact source prose files before calculating. The finite coverage is all ordered square-zero 2x2 sums over F2 through four slots, F3 through four slots, and F5 through three slots (zero pads, not paid calls); three explicit rank-two block fixtures; 54 newly assembled two-call F2 query-normalization words with all270 instruction steps checked; 81 padded six-target rank profiles; four mathematical premise controls, one zero-call counting-convention check and three parser controls. The RESULT records exact domains, case counts, rank histograms and streamed certificate digests. + +No predecessor verifier, constructor or6808 eight-role attainer is imported or run. Small classical fixtures can overlap prior examples; they are not new constructions. These finite checks corroborate the written all-field lemma and separate characteristic-two query application; they do not prove the arbitrary-dimension statement by enumeration. No proof-kernel or human acceptance is claimed. + +``` +python3.12 -B scripts/research_package.py --package research/clean-query-rank-optimum +python3.12 -B scripts/check_research_commit.py --package research/clean-query-rank-optimum --check-source-history --check-modes +``` + +SOURCES binds canonical selection/catalogue/legal provenance. SOURCE-PINS +separately binds the four package-local mathematical source copies to their +exact foreign head/path/blob/mode/size/hash, checked against source trees at +acquisition. This is not a generic foreign-ancestry assertion; cached refs +are not publication history. Direct replay needs no Git/network/live external +files. VERIFY.inputs=[] matches that runtime closure. Default normal/O +commands will compare the complete typed retained RESULT; no self-hash cycle. + +## Open next questions and limits + +The known seven-call, total-rank-seven source boundary above prevents an unrestricted rank-eight claim. No broader classification or follow-on construction is reserved; helper minimality is not reproved. + +For physical use, bind one native caller and price zero-helper preparation, +ownership, every free basis and paid map, layout/movement, chronology, +precision, stock and restoration outside this clean endpoint. These are +unknown. All five selected assumptions and the frontier remain unchanged; +no native supplier, new kappa or complete physical/recursive bill is supplied. +The bit-new-register-model card remains explicitly changed/partial, with its +original native conversion gate unmet. The family decision is a narrow +lower-bound audit, not a new construction/search round. + +## Credit and exposure + +Credit Petalas6800 for normalization, dirty/projection rank method and the +clean/dirty distinction; ToikY/Codex6808 for credited rank8 attainment and +helper minimum; Josie Elliston6138, Petalas6122, Cinna Davis, Ali Romman5617, +Matarener6114 and retained distinct5007/5857/1974/2027 lineage. Rank +factorization, UV/VU fixed-space transport, rank-nullity and dual-number +normalization are classical. [LICENSE](LICENSE) and [NOTICE](NOTICE) retain +Apache-2.0 and source attribution. + +Root proposed the clean fixed-space recipe during preclaim orientation, +then source review identified the projection inequality as prior work. +Related source-aware OpenAI Codex proposal, proof, implementation and review +roles see those sources/recipe; this is not blind independence, human or +proof-kernel acceptance. No earlier result or construction is recounted. + +Identity calls N=0 are legal source-model padding and can be omitted. The fifth control enforces only the checker's canonical count of nonzero paid calls; it is not a mathematical obstruction or a forbidden source gate. The first successful packet is retained in the external receipts; its zero-control wording was clarified before freeze. diff --git a/research/clean-query-rank-optimum/RESULT.json b/research/clean-query-rank-optimum/RESULT.json new file mode 100644 index 0000000000..4b22bcf529 --- /dev/null +++ b/research/clean-query-rank-optimum/RESULT.json @@ -0,0 +1,2723 @@ +{ + "actual_F2_normalization": { + "actual_instruction_steps": 270, + "actual_nonzero_paid_instructions": 108, + "field": 2, + "new_literal_words": 54, + "ring": "F2[Q]/(Q^2-1)", + "scalar_roles": 2, + "scope": "New tiny actual-alphabet normalization fixtures; no old six-target attaining word.", + "words": [ + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "e4a69a5d2b0b3c675d486948b11c9a26487bf0291fc7f517fcdbfc672e939eec", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "6ad5498b50a07529df22e7f46076bd7cbd866cf0e69235eb9374e913fd34defe", + "word_sha256": "280876fc31c3c09b53ec37d246ba3d5be571043f23f124697812eb27c5a8138e" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d35470857d4344fd226046f4e6757adf8ee14aec24a6e1ac4aa725417ac9e512", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "492e1e4c3f37749a404cf70f86a224b623ef220358c36821037fb8f0a84d85a3", + "word_sha256": "97ee93e8234e7ed17cd8d78f6560abf352ab0e1c60b2390baf440fb43a2f985b" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "1c490bc033952c0bc0dce6ac3e050a699a5714cc42615fcfa6645b8f3c9fb354", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "ff5634c2b63bf2a0cdbd60b1316b0a72b68ee7f871b27a5449aa5b2084b0696a", + "word_sha256": "ff506b8cf46f7477af1888bb27db786a6eeafb0bb2c16e0d17a904e68d2b8e2e" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d35470857d4344fd226046f4e6757adf8ee14aec24a6e1ac4aa725417ac9e512", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "3f7b629e5d7ba403cd0495f86c081007174f459da69983e1b5a97b2b3fe0ce4b", + "word_sha256": "2c919899a1d06ac5bea31a1878387e19b6ee91ed998b29d4735dde0d956b58d8" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "4e1da4a186d047285453e98d75802ec57b330d6a92775ab06fe81ae3b3c2c0c0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "2ec196d80b2efa25b551f22d32ee698917d0dbb0ee7c38dbde7bc42a25cb92d7", + "word_sha256": "3b656e8105b4ab63bd99adb07f6112770f5484b05ae56c0dd654250b840b4fd2" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "bba813f3d6a3cd34ff1deb6797b2dcab0f8ca944bba051c4f866a5d100fe3363", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "062f7fc0775e025e60dc162b43c0e20d08babf9e5614872ceea3644fc9b71948", + "word_sha256": "a0bb68c3fdcb6d39059db06d38e5227060110c1b4bd2e4d0bd0dd068afe15607" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "97222764868d86ec58f25dedce9661d27d3c15a72510dac5bf0e216bd3902aee", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "39d6b872d81288508af6c1a3503169b71631aec26f4a5bddeb3d32e7cfdef09f", + "word_sha256": "fd587efdc48e5ec5384704178f36e31be197a672b75e7cb5fc10c78efe9a1a12" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "c70f4763ef78279f4d3badfab86f7995d585929e67faf5d45aa2bdeda05701b0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "f46f710d0e0bb3a71e743a503f48d382f34bf02088cc5cf1eda44890c946d059", + "word_sha256": "5c6df055abcb720ebfa539a4c8d1e1d6134bce67ee8eef8349168f6712abec16" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d35470857d4344fd226046f4e6757adf8ee14aec24a6e1ac4aa725417ac9e512", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "2a3fb5de76defa18d1b58be12643ca9efe0059fd482cdc1f1307bd9d7e9051c4", + "word_sha256": "daf979e41c5c4d585cf8342aa968535a1202a8f4e46866e8040bcb2f84b622e9" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "e4a69a5d2b0b3c675d486948b11c9a26487bf0291fc7f517fcdbfc672e939eec", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "a869a790617c38993802ba45089f6a3266bd24ba9814b05986047603fb6f9488", + "word_sha256": "4bcecf193a4ae08e30e58fe9d73660a58074844bb69e177d7c277a87d8ea4347" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "364693cd16304efb9cd521be2d1ed246986b7cc8ebdc6834270ddf467a4e271c", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "604babbf8def9a43570444e908b60499b0188af5d75814e39940c6eebc2e1cde", + "word_sha256": "2af002012494878932c3654be85a42e5b3407ee9b47129548c662ec4c678a92f" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "ad222b8ce8fc2b42f7f9bb8d7bb0cb967b2b021259c1776f90ac68b137fec9a1", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "2d94d5c10285281a78d828e2b26410e4676cfc114d122c6b797f16a1bf3f3b71", + "word_sha256": "1b3dcce431e47b682dce72460c9c8f0713ec94bdbfa10070d1fe8a25485caa7e" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "364693cd16304efb9cd521be2d1ed246986b7cc8ebdc6834270ddf467a4e271c", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "ffe8787d905a4c2cd670f83fb1fbc4e015995f8a9938692e0647e2742778a6b4", + "word_sha256": "d3b3a29456bd5a542285602195aa1edd8a8c6f16c8e2404a2c6a4093ffc4d54f" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "c16f2f73c34aba4b41ca9c8dd68eb494efd34409332de5bb5bdda421436d388e", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "7111dd5f6544c2b6aa89dc1327c134f9a1f6e4e8539101ea97e30d66a460e4f9", + "word_sha256": "7db504e0588de29b34fa7affd7e1fbc403d9f1c0291d10f8b1f7eca17b1b43bd" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "c70f4763ef78279f4d3badfab86f7995d585929e67faf5d45aa2bdeda05701b0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "b2ebf2f67a842851668972419062a9a37ec6062c5e1746dafff8974f59076256", + "word_sha256": "fb59ff46e831fccb00ce476b1fced0760c6b281eb43422d6029e81b77850b21b" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "3340f99a9196e3a541b742bee94cf69fbda4a3e6e8a182da946995a1d84ea4fd", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "eb90183b42bf55ba4b646bfc5dee780cf34b012ecc479e303156c4e3083123bf", + "word_sha256": "70f025214c8ed66cce76a39db2d3e5b2560684b2a79a67b8786308ec004a9b5d" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "bba813f3d6a3cd34ff1deb6797b2dcab0f8ca944bba051c4f866a5d100fe3363", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "bb601a0ce76083ea8d2174e8069701841bd7ac0d2af038a400ebb069fcc9929b", + "word_sha256": "97c7b6beb9a19b572ccbadb3582af726a4c658d446cb69bdc520ba8d37875e21" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "364693cd16304efb9cd521be2d1ed246986b7cc8ebdc6834270ddf467a4e271c", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "92a4c3ef1c458c60b70f0a94bf6f97d500f3ed1e0f207a3d4fc7fae7eb98b813", + "word_sha256": "bb1ff9ea0afde018f03607b036d2db333f8ffc3feb0bb9a0e33105cfaadc1b76" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "4e1da4a186d047285453e98d75802ec57b330d6a92775ab06fe81ae3b3c2c0c0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "d0052ea42a9980ec13822193697307cc99345042cafb8aa3364eab70a7867925", + "word_sha256": "ed5d6a7e5d9e4f503f5d562445bc288ba31796c721ab2787f6c92d1af76f9a5c" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d35470857d4344fd226046f4e6757adf8ee14aec24a6e1ac4aa725417ac9e512", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "4a53cec59ca7d33748e6be5c1eb273e7042e934dc53d61f3534fe49a53c089e5", + "word_sha256": "f6521cc893280d42e7d8a5efe04847df48ada55f6fb7f35f42e565793c809e56" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "bba813f3d6a3cd34ff1deb6797b2dcab0f8ca944bba051c4f866a5d100fe3363", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "efdb3e281b6d9afcd5ec98b143e75ec70236953b382dcfe074932214e523ecd4", + "word_sha256": "8a239e7e1b6a41aca8e46ec2361bc1ff564d453179513e19b5e18916688777e1" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d35470857d4344fd226046f4e6757adf8ee14aec24a6e1ac4aa725417ac9e512", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "7589507647fb97ce8c6ce4b552befb82e22b5425fc1d30656ea8c6f8c560aaca", + "word_sha256": "dcc47e5c4c52ac6c689e32a0ecc3b29dcb629c81990f3f5d0929388e4b27f5cd" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "e4a69a5d2b0b3c675d486948b11c9a26487bf0291fc7f517fcdbfc672e939eec", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "b96adbdd695cea75ae0e9d182f43a8feb7d232a5e2da4fc75a3b69ac5c3d678d", + "word_sha256": "1d6fd618b49bf948f8d0486f283669dcb34940785961c1655379c0da7bb07752" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "1c490bc033952c0bc0dce6ac3e050a699a5714cc42615fcfa6645b8f3c9fb354", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "aea52b40b2216a42df5fbf9b4bf35621532195647dd1b724401542648a0271f3", + "word_sha256": "77b8ff2a6f24e42882f0d0b7cdc6d03534fb723ecc149d9edb055d19624da7b3" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "c70f4763ef78279f4d3badfab86f7995d585929e67faf5d45aa2bdeda05701b0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "925d637ce503d31efc71e2d150d106ae3b68c6a1eb9993df1608e740bcec78ad", + "word_sha256": "d99b8779f7a4a6896306410673daab4ba1fde53707b0c1f6d09c892e11933fea" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "97222764868d86ec58f25dedce9661d27d3c15a72510dac5bf0e216bd3902aee", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "c6eb2fdc2e53805a6d31f286fc23b9cb9a0a298367003ceb9ccab794a7085246", + "word_sha256": "437639509a49e9a4b817cc239464e589aa1200d466c6058cc17a284776b1ebdc" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d35470857d4344fd226046f4e6757adf8ee14aec24a6e1ac4aa725417ac9e512", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "12e84d1b2ce1f7eb7a520da9d9992808996e66ff491935368b7abbf69f6fa617", + "word_sha256": "f7402154ae615b3580f91a32eba0c2356115b256c484e1de5a36ab62a5b6e8fa" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "c16f2f73c34aba4b41ca9c8dd68eb494efd34409332de5bb5bdda421436d388e", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "aa70b879a6d9c8607c871cf75773d6273277375a747ed2c5a08714704ae120c3", + "word_sha256": "2f8fd516c3d4af0a2967c80cf0b2cea8745d46ebb1b97dfb308935baaeedd75f" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "364693cd16304efb9cd521be2d1ed246986b7cc8ebdc6834270ddf467a4e271c", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "44dade5e96f7ff5f357ea4ad456ced938cec08d271b1c0ef1e3129e272b158bd", + "word_sha256": "e1251cf2e9ab71b59c7fa707a3be73e9616b87071caebe1f124a81f24e8502c5" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "c70f4763ef78279f4d3badfab86f7995d585929e67faf5d45aa2bdeda05701b0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "492b47bc8b75a626295156c63ebf5ae7d85ea4852ca27ab240a91c07ba1a0761", + "word_sha256": "35594147aea86556497e51da2f6b9e38e13ad1d02c6c0ad2d27e4eda88e756ef" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "364693cd16304efb9cd521be2d1ed246986b7cc8ebdc6834270ddf467a4e271c", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "46312d8c1173f201c900d74b28f26c0b0d3aea94e0e0c7483eb8e662ef2b3f3e", + "word_sha256": "f76347caa03f6e0b5a0e347ef281023bd64d1c9d4b2d87967ed068f298fe1723" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "e4a69a5d2b0b3c675d486948b11c9a26487bf0291fc7f517fcdbfc672e939eec", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "ffc941428a84fb96256dcd0454c024173cdc60cd112175b317a8cc9d85f316d4", + "word_sha256": "c0c74b6bd541c2a4405e2e4d2827c0988bca41c302b09d0e18bd3b59c197aac8" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "ad222b8ce8fc2b42f7f9bb8d7bb0cb967b2b021259c1776f90ac68b137fec9a1", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "fe043d7339c994b82056673c67001d9eec3a166fb29b40c72962cd4d679fb5eb", + "word_sha256": "3d63779f3adb6e32c80b4799674b34aee0b6b4d2dff7f2813206d305e9696648" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "bba813f3d6a3cd34ff1deb6797b2dcab0f8ca944bba051c4f866a5d100fe3363", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "26e2b25fb61bfc6bacf2ba3620042ba5ab94288fa20b66aa037c7652a8f7eb29", + "word_sha256": "8bd42b88e58cd0f1b5adbf0bee78b86a348c9da3fcac9a12ef50e36c458482d0" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "3340f99a9196e3a541b742bee94cf69fbda4a3e6e8a182da946995a1d84ea4fd", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "415d2a3a5428e5e3e81672be5ac64e78c20e1807196a868bacbf8f5af9c5db62", + "word_sha256": "7fb4033ecf4d45dc4d67f57a906bcb35f851c503dd95d19f8dcefcc7434952c2" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "364693cd16304efb9cd521be2d1ed246986b7cc8ebdc6834270ddf467a4e271c", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "9a2b80ebf33f73fb5f107483290e0d8fcfd8ee4586cb76b674485f014466bf4e", + "word_sha256": "3ff705b4cf14cfcf561810eaef7a49802ed9f4ae43e76dec4b739a656bcd9b04" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "4e1da4a186d047285453e98d75802ec57b330d6a92775ab06fe81ae3b3c2c0c0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "9e046d257d5b326c03acda6012506df8215abf8d8bffd8b13e93e2ae12d2b860", + "word_sha256": "afa35908ee70c801908eadb432e69e8e37078af730b06d6358783664e18aadd9" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d3e75dcff00273b9a48b2cecfaf71ba69eae175f6118bd737bd5536829fcb178", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "31a7a98cd26df67b9a7e8e770943753ab342d7c9b269d0dca44805fc12f3c762", + "word_sha256": "f2378da91861a381bb8737b554e1f2ee8de9d2917b644767dc9e5d766de55997" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "3340f99a9196e3a541b742bee94cf69fbda4a3e6e8a182da946995a1d84ea4fd", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "d9244866dd8321324b29d72fca1d775263b2d869f2fcddeb4472ca999e83b66c", + "word_sha256": "0374483eec25b9e52e2a4010ff6f1c94fc1bef09f54b29b859c504bb5d04b67b" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d3e75dcff00273b9a48b2cecfaf71ba69eae175f6118bd737bd5536829fcb178", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "2329ff0ac7305b3dddd42a5b983d80358e7af03e448d78061513b1041137c2b1", + "word_sha256": "dc65f1511a58d996a3bf6fd448755025a92c75878f036c287f776db4b155135d" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "c16f2f73c34aba4b41ca9c8dd68eb494efd34409332de5bb5bdda421436d388e", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "ddf624b4f8cd6571df27101fa5d4726b7a4c9a194f2f771ed62628dcaa4923c6", + "word_sha256": "fad9151601aa3e4f82f6b3c277c6dcad678214ef8b9b5713c7f7e650c9cbd15f" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "97222764868d86ec58f25dedce9661d27d3c15a72510dac5bf0e216bd3902aee", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "3da6f36354df5462ccfc6a3070f48c9db0f616bf6472cfc280ea32efcb9310b9", + "word_sha256": "bbbc3fa67a44c4d16e7a64b483675c60a0c0dd32f1348945b1a6b78bd7159041" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "ad222b8ce8fc2b42f7f9bb8d7bb0cb967b2b021259c1776f90ac68b137fec9a1", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "de1c40e92b7a6d7172e8a602d9c9dcb26c333c3c0f6a495b5f1238d7e577d1da", + "word_sha256": "ec456c7111764c867814f92a190f97f0046628945a293e89c9cbd66ded1a895c" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "1c490bc033952c0bc0dce6ac3e050a699a5714cc42615fcfa6645b8f3c9fb354", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "3cd8e5ec24a95d5b126db97e2bfb5ed21403b1538c893c4086c190592895a5ca", + "word_sha256": "d454f4fab16cb5fad50d4dcc781a11e31b6cf7439bb2798ef32a65469062e131" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d3e75dcff00273b9a48b2cecfaf71ba69eae175f6118bd737bd5536829fcb178", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "f64a88a3d6c4dda92945e790d9410296f359afc1c00199b5cef613193826fee3", + "word_sha256": "7ac908f5c37301609f40d2239cc68fdd04570bac83cf3aa8ef59260e367e2401" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "c16f2f73c34aba4b41ca9c8dd68eb494efd34409332de5bb5bdda421436d388e", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "a30f40416baae52239159c41322c8a30d26e966c02aad1679a36adcdcaae072c", + "word_sha256": "c86a96305ad08bde1db7b9f3f65a27b99a5996d2dec01f51aebfbed80343d6bd" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d3e75dcff00273b9a48b2cecfaf71ba69eae175f6118bd737bd5536829fcb178", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "d0ebbef725244b525b26e761f32cc8bbfad1b7a0f5f56ca1c3dac409b90fb5ba", + "word_sha256": "a4a280a3b312cb3c93c2a66cfa9c47798c305e6863fb02d0a0229a263a0624d1" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "97222764868d86ec58f25dedce9661d27d3c15a72510dac5bf0e216bd3902aee", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "40a83ac5ab4b69eb5f0b7d68a38a9703ec94275212d8baf227924b1181d218ae", + "word_sha256": "1807214d6a4debd8761ca362053e1d6ede82277522a1e190fe9623bc1e53691f" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d3e75dcff00273b9a48b2cecfaf71ba69eae175f6118bd737bd5536829fcb178", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "6ef44f9bae3178910764cc91c7ef8c92e53b0d54d813d7ef4d689ee8b004b5c9", + "word_sha256": "16042d15ca592e50885f8e7ddd1024c1494b058fd1392584f4a0decce6df62b2" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 1, + "complete_ring_sha256": "4e1da4a186d047285453e98d75802ec57b330d6a92775ab06fe81ae3b3c2c0c0", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "5742b1653ce36884124ef7538a54b85a32138354b3648d26bffddd5fe0dce6b6", + "word_sha256": "5422a23e799c9a87445c43d1c4ae18075e5140711ed5b19c3e7379f653c4d7b3" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "3340f99a9196e3a541b742bee94cf69fbda4a3e6e8a182da946995a1d84ea4fd", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "716c0e02605a7234ed8bcda02199cd4f167d1f3f54607530a65268e98976d973", + "word_sha256": "7509f4fb7ef447f9f885ce2755ca530e1a4a0993d09b54b6d696e435d84c90c7" + }, + { + "C": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "1c490bc033952c0bc0dce6ac3e050a699a5714cc42615fcfa6645b8f3c9fb354", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "f710cb40879b0f99b0def3207cfbc29dc471441dc295c2cfcea8398b3ab55745", + "word_sha256": "2616f6bdcf43f764b5321d9d53768ba6580146e838816026046df33383a39f3d" + }, + { + "C": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "ad222b8ce8fc2b42f7f9bb8d7bb0cb967b2b021259c1776f90ac68b137fec9a1", + "full_fixed_dimension": 1, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "2f0addba1699fc7f0648b6d4086a93ee734f62868981fa75ea2faf780a207c18", + "word_sha256": "321bb901be9c78283a9ffb3f9be8a1dfdec50dd3e6ba627ebfb7cfae6ea295e2" + }, + { + "C": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "actual_clean_dimension": 0, + "complete_ring_sha256": "d3e75dcff00273b9a48b2cecfaf71ba69eae175f6118bd737bd5536829fcb178", + "full_fixed_dimension": 0, + "normalized_ranks": [ + 1, + 1 + ], + "step_sha256": "15dd564d1d06a599b4f006b4b40bd2caa11e09418f4d20f693fa360fe151ce26", + "word_sha256": "e752715c48b77dee610bbd4db967cf1ff95549f64bc94048704b2617e153e6a9" + } + ] + }, + "algebraic_rank_cases": [ + { + "certificate_sha256": "75724a5797d0fa0230726f51ca2d342c45cf2fc4f0cc513a2f7e945651552bed", + "field": 2, + "histogram": { + "0/0/0/0/0": 1, + "1/0/0/0/0": 1, + "1/1/1/0/1": 3, + "2/0/0/0/0": 1, + "2/1/1/0/1": 6, + "2/2/2/0/1": 3, + "2/2/2/1/1": 6, + "3/0/0/0/0": 1, + "3/1/1/0/1": 9, + "3/2/2/0/1": 9, + "3/2/2/1/1": 18, + "3/3/3/0/1": 21, + "3/3/3/2/1": 6, + "4/0/0/0/0": 1, + "4/1/1/0/1": 12, + "4/2/2/0/1": 18, + "4/2/2/1/1": 36, + "4/3/3/0/1": 84, + "4/3/3/2/1": 24, + "4/4/4/0/1": 21, + "4/4/4/1/1": 60 + }, + "histogram_axes": [ + "slots", + "nonzero_paid_summands", + "R", + "fixed_dimension", + "maximum_rank" + ], + "maximum_slots": 4, + "nonprojection_with_nonzero_fixed_space": 120, + "ordered_tuple_cases": 341, + "scalar_roles": 2, + "square_zero_matrices": 4, + "zero_is_padding_not_paid": true + }, + { + "certificate_sha256": "23700b81bd2b323f7425ed0cc4f24ad48b51aae0be837c8aeb567a34bece0eba", + "field": 3, + "histogram": { + "0/0/0/0/0": 1, + "1/0/0/0/0": 1, + "1/1/1/0/1": 8, + "2/0/0/0/0": 1, + "2/1/1/0/1": 16, + "2/2/2/0/1": 40, + "2/2/2/1/1": 24, + "3/0/0/0/0": 1, + "3/1/1/0/1": 24, + "3/2/2/0/1": 120, + "3/2/2/1/1": 72, + "3/3/3/0/1": 296, + "3/3/3/1/1": 216, + "4/0/0/0/0": 1, + "4/1/1/0/1": 32, + "4/2/2/0/1": 240, + "4/2/2/1/1": 144, + "4/3/3/0/1": 1184, + "4/3/3/1/1": 864, + "4/4/4/0/1": 2296, + "4/4/4/1/1": 1800 + }, + "histogram_axes": [ + "slots", + "nonzero_paid_summands", + "R", + "fixed_dimension", + "maximum_rank" + ], + "maximum_slots": 4, + "nonprojection_with_nonzero_fixed_space": 3120, + "ordered_tuple_cases": 7381, + "scalar_roles": 2, + "square_zero_matrices": 9, + "zero_is_padding_not_paid": true + }, + { + "certificate_sha256": "8530673c5bbdb14e33c1b11f8b7144ed11f0f241b9bbb0c0cf0b34c1e0b75b03", + "field": 5, + "histogram": { + "0/0/0/0/0": 1, + "1/0/0/0/0": 1, + "1/1/1/0/1": 24, + "2/0/0/0/0": 1, + "2/1/1/0/1": 48, + "2/2/2/0/1": 456, + "2/2/2/1/1": 120, + "3/0/0/0/0": 1, + "3/1/1/0/1": 72, + "3/2/2/0/1": 1368, + "3/2/2/1/1": 360, + "3/3/3/0/1": 10584, + "3/3/3/1/1": 3240 + }, + "histogram_axes": [ + "slots", + "nonzero_paid_summands", + "R", + "fixed_dimension", + "maximum_rank" + ], + "maximum_slots": 3, + "nonprojection_with_nonzero_fixed_space": 3720, + "ordered_tuple_cases": 16276, + "scalar_roles": 2, + "square_zero_matrices": 25, + "zero_is_padding_not_paid": true + } + ], + "mathematical_controls": [ + { + "name": "non_square_zero_identity", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "coupling is not square zero", + "witness": { + "N": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "false_R": 2, + "false_required": 4, + "fixed_dimension": 2, + "rank": 2, + "square": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ] + } + }, + { + "name": "payload_only_helper_leak_and_Q1_collapse", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "not a complete clean-column endpoint", + "witness": { + "Q1_actual": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "Q1_target": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "actual": [ + [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ] + ], + "helper_Q": 1, + "helper_constant": 1, + "public_column": [ + [ + 1 + ], + [ + 0 + ] + ] + } + }, + { + "name": "projection_assumption_excludes_legal_clean_case", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "false extra projection assumption", + "witness": { + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "actual_word": [ + [ + "free", + [ + [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ] + ] + ], + [ + "paid", + [ + [ + 0, + 0 + ], + [ + 1, + 0 + ] + ] + ], + [ + "free", + [ + [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ] + ] + ], + [ + "paid", + [ + [ + 1, + 1 + ], + [ + 1, + 1 + ] + ] + ] + ], + "clean_dimension": 1, + "public_column": [ + [ + 1 + ], + [ + 0 + ] + ], + "rank_certificate": { + "E": [ + [ + 0, + 1 + ], + [ + 1, + 0 + ] + ], + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M_is_projection": false, + "R": 2, + "d": 1, + "fixed_basis": [ + [ + 1 + ], + [ + 0 + ] + ], + "maximum_rank": 1, + "rank_I_minus_E": 1 + }, + "square": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ] + } + }, + { + "name": "Q_dependent_free_gate", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "Q-dependent free gate", + "witness": { + "actual_clean_public_column": [ + [ + 1 + ], + [ + 0 + ] + ], + "forbidden_free_pair": [ + [ + [ + 0, + 0 + ], + [ + 0, + 1 + ] + ], + [ + [ + 1, + 0 + ], + [ + 0, + 0 + ] + ] + ] + } + }, + { + "name": "zero_paid_counting_convention", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "zero omitted from nonzero paid count", + "witness": { + "N": [ + [ + 0, + 0 + ], + [ + 0, + 0 + ] + ], + "scope": "Legal identity padding is omitted from the canonical nonzero paid count; not a forbidden source-model gate." + } + } + ], + "overlap_disclosure": "Tiny2x2matrixvalues may coincide with predecessor examples; no old6808eight-roleattainer runs.", + "parser_controls": [ + { + "name": "duplicate_JSON", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "duplicate JSON key", + "witness": { + "input": "duplicate key" + } + }, + { + "name": "floating_JSON", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "noninteger JSON number", + "witness": { + "input": "1.0" + } + }, + { + "name": "nonfinite_JSON", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "noninteger JSON number", + "witness": { + "input": "NaN" + } + } + ], + "rank_profile_necessity": { + "attainment": "Cited PR6808 rank8 witness; its word/data/constructor/verifier is not replayed.", + "call_limit": 4, + "higher_call_counts": "Outside this optimum statement.", + "necessary_profiles": [ + [ + 2, + 2, + 2, + 2 + ] + ], + "necessary_total_rank": 8, + "padded_profiles_checked": 81, + "productive_dimension": 6, + "rank_cap": 2 + }, + "rank_two_block_fixtures": [ + { + "E": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "M": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "M_is_projection": false, + "R": 4, + "U": [ + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ] + ], + "V": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "field": 2, + "fixed_basis": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "fixed_dimension": 2, + "maximum_rank": 2, + "rank_I_minus_E": 2, + "scalar_roles": 4, + "scope": "One classical A tensor I2 / B tensor I2 factorization fixture.", + "summand_ranks": [ + 2, + 2 + ], + "summands": [ + [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ] + ] + }, + { + "E": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "M": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "M_is_projection": false, + "R": 4, + "U": [ + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ] + ], + "V": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "field": 3, + "fixed_basis": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "fixed_dimension": 2, + "maximum_rank": 2, + "rank_I_minus_E": 2, + "scalar_roles": 4, + "scope": "One classical A tensor I2 / B tensor I2 factorization fixture.", + "summand_ranks": [ + 2, + 2 + ], + "summands": [ + [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ] + ] + }, + { + "E": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "M": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "M_is_projection": false, + "R": 4, + "U": [ + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ] + ], + "V": [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ], + "field": 5, + "fixed_basis": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ], + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "fixed_dimension": 2, + "maximum_rank": 2, + "rank_I_minus_E": 2, + "scalar_roles": 4, + "scope": "One classical A tensor I2 / B tensor I2 factorization fixture.", + "summand_ranks": [ + 2, + 2 + ], + "summands": [ + [ + [ + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 1 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ] + ], + [ + [ + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + 0 + ] + ] + ] + } + ], + "schema_version": 1, + "scope": "All-field fixed-subspace lemma corroboration plus F2 actual-query reduction; no higher-call/global classification.", + "source_programs_executed": false, + "source_sha256": { + "predecessor/PR6800-PROOF.md": "e82afe4b80b34dcdd69b59c2104f88cf9242c8b93554442e30c35de305deff98", + "predecessor/PR6800-README.md": "bec1134b11d08664897821f28888dda6f88946d7ca9a405be3f95802aae26387", + "predecessor/PR6808-PROOF.md": "511fad8592b04cfc420a7b184beb9fe3638fc2cbadb6d64057de1f3cb04d7344", + "predecessor/PR6808-README.md": "1c061e94ca9a4e72d3c6223dfc812b821a1c214b82731a26ad4d6e3ad1f87d90" + }, + "status": "PASS_CLEAN_FIXED_SUBSPACE_RANK_BOUND" +} diff --git a/research/clean-query-rank-optimum/SOURCE-PINS.json b/research/clean-query-rank-optimum/SOURCE-PINS.json new file mode 100644 index 0000000000..55269f9122 --- /dev/null +++ b/research/clean-query-rank-optimum/SOURCE-PINS.json @@ -0,0 +1,49 @@ +{ + "schema_version": 1, + "files": [ + { + "local_path": "predecessor/PR6808-README.md", + "source_repository": "ToikY/integer-mult-bounds", + "source_commit": "518351a389e32e2ccdf0a1ca55580e9c60d65492", + "source_path": "research/clean-two-helper-query/README.md", + "git_blob": "4da529922808bf45499fac4521280ee2a7ea1d33", + "sha256": "1c061e94ca9a4e72d3c6223dfc812b821a1c214b82731a26ad4d6e3ad1f87d90", + "bytes": 6142, + "mode": "100644", + "usage": "Inert source prose/task/legal only; no source executable fetched or executed." + }, + { + "local_path": "predecessor/PR6808-PROOF.md", + "source_repository": "ToikY/integer-mult-bounds", + "source_commit": "518351a389e32e2ccdf0a1ca55580e9c60d65492", + "source_path": "research/clean-two-helper-query/PROOF.md", + "git_blob": "e6b8c65406b2866abe3859fb11b7fcb290d4d990", + "sha256": "511fad8592b04cfc420a7b184beb9fe3638fc2cbadb6d64057de1f3cb04d7344", + "bytes": 8396, + "mode": "100644", + "usage": "Inert source prose/task/legal only; no source executable fetched or executed." + }, + { + "local_path": "predecessor/PR6800-README.md", + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "c94197e40c9e8a25f643d776160659871e5ce9ac", + "source_path": "research/restored-dirty-query-capacity/README.md", + "git_blob": "8df37528f5d2f9f5e818f71d30c7106c7ae43082", + "sha256": "bec1134b11d08664897821f28888dda6f88946d7ca9a405be3f95802aae26387", + "bytes": 7386, + "mode": "100644", + "usage": "Inert source prose/task/legal only; no source executable fetched or executed." + }, + { + "local_path": "predecessor/PR6800-PROOF.md", + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "c94197e40c9e8a25f643d776160659871e5ce9ac", + "source_path": "research/restored-dirty-query-capacity/PROOF.md", + "git_blob": "c5f42331896c9bfcbe348c9ecd1a5c9431503fdb", + "sha256": "e82afe4b80b34dcdd69b59c2104f88cf9242c8b93554442e30c35de305deff98", + "bytes": 6061, + "mode": "100644", + "usage": "Inert source prose/task/legal only; no source executable fetched or executed." + } + ] +} diff --git a/research/clean-query-rank-optimum/SOURCES.json b/research/clean-query-rank-optimum/SOURCES.json new file mode 100644 index 0000000000..c64cc0b47d --- /dev/null +++ b/research/clean-query-rank-optimum/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + }, + { + "path": "certificates/selected-result.json", + "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a", + "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa", + "usage": "provenance" + }, + { + "path": "LICENSE", + "usage": "provenance", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + } + ], + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a" +} diff --git a/research/clean-query-rank-optimum/TASK.json b/research/clean-query-rank-optimum/TASK.json new file mode 100644 index 0000000000..47213d7a94 --- /dev/null +++ b/research/clean-query-rank-optimum/TASK.json @@ -0,0 +1,97 @@ +{ + "schema_version": 1, + "task_id": "bit-new-register-model", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + "scope_status": "changed", + "actual_scope": "Clean fixed-productive-subspace extension of the credited projection rank argument, proving minimum total paid rank8 for six formal query targets/at most4 rank2 square-zero calls/any finite initialized-clean helper count.", + "scope_change_reason": "Take PR6808 explicit open paid-rank-optimality request. A bounded written lower-bound/application audit; not a new construction, invariant, native conversion or complete supplier.", + "bottleneck_link": "Separates formal call/rank optimality from helper minimality and actual physical costs before any mechanism expansion.", + "budget_minutes": 120, + "stop_rule": "Stop after this fixed four-call paid-rank optimum and bounded new fixed-subspace corroboration. No unrestricted-call optimum, general clean-capacity sufficiency/classification, new construction or physical supplier expansion. Reserve at least30actualminutes aftersciencefreeze.", + "outcome": "partial", + "evidence": "New written clean fixed-subspace necessity and fixed four-call totalrank8 optimum, with new bounded fixed-space/query-normalization checks. Old6808 attainment/helperminimum and6800/6138seven-callrank7boundary citedonly. FirstactualPASS0.677866167s21.671875MiB; no nativecaller orcompletephysicalbill.", + "author": "ToikY with substantial OpenAI Codex assistance", + "ai_assistance": "Source-aware root proposal, proof/implementation, overlap/metadata and related-role challenge. Preclaim recipe/source exposure disclosed; not blind independent/human/kernel acceptance.", + "selection": { + "kind": "explicit_handoff", + "source_pr": 6808, + "source_head": "518351a389e32e2ccdf0a1ca55580e9c60d65492", + "projection_predecessor_pr": 6800, + "projection_source_head": "c94197e40c9e8a25f643d776160659871e5ce9ac", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/6808#issuecomment-6700319403", + "hub_pointer": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19452164", + "picker_draw": null + }, + "family_gate": { + "decision": "NARROW_BOUNDED_AUDIT", + "scope": "One missing clean-column necessity implication; no new construction/family search or full-supplier claim.", + "remaining_native_budget": null + }, + "exposure": { + "root_preclaim_recipe": "Root proposed stacked-rank fixed-subspace argument during priorverificationwait beforecurrentclaim; sourceorientation thenidentified6800projectioninequality as explicitprior. ActualI+QNalphabet confirmed andconstantI+Nabsorption required. Recipe unacceptedbeforeclaim, no scientificprogramrun.", + "excluded_prior_work": [ + "6800projection/dirtycapacity theorem andrankmethod", + "6808rank8attainer andhelperminimum", + "6138/6122workspace-freecapacity" + ], + "source_programs_executed": false, + "attainer_status": "Source6808 writtenattainment premise only; its scientific engine/constructor/eight-role word not replayed." + }, + "physical_obligations": { + "zero_helper_preparation_ownership": null, + "constant_basis_native_price": null, + "actual_caller_chronology_routing": null, + "precision_stock_restoration_outside_clean_contract": null, + "complete_physical_recursive_invoice": null + }, + "open_questions": [ + { + "question": "Can one actual native caller consume the clean word at a complete price?", + "why_it_matters": "Formal paid rank is not a physical recursive invoice.", + "first_step": "Bind actualzero-helper preparation, everybasis/paidmap, rolelayout, movement/precision/stock andrestoration to onecaller andcompletebill.", + "blocked_by": "No nativecaller orpricedbasis implementation is supplied." + } + ], + "known_boundary": "Credited PR6800/6138 n6,k7,cap1 gives workspace-free totalrank7, also clean. Rank8 withoutfour-callcap is false; no new unrestricted optimum or replay is claimed." +} diff --git a/research/clean-query-rank-optimum/VERIFY.json b/research/clean-query-rank-optimum/VERIFY.json new file mode 100644 index 0000000000..6eca0b3758 --- /dev/null +++ b/research/clean-query-rank-optimum/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": 120, + "checks": "New finite fixed-subspace/rank-factorization and actual-alphabet normalization corroboration with witnessed premise controls; no predecessor attainer/program." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same complete typed retained packet and explicit optimized-mode guards." + } + ] +} diff --git a/research/clean-query-rank-optimum/predecessor/PR6800-PROOF.md b/research/clean-query-rank-optimum/predecessor/PR6800-PROOF.md new file mode 100644 index 0000000000..c5f4233189 --- /dev/null +++ b/research/clean-query-rank-optimum/predecessor/PR6800-PROOF.md @@ -0,0 +1,171 @@ +# Restored dirty helpers do not increase square-zero query capacity + +This contribution was produced by Nick Petalas. Apache-2.0. + +## 1. Statement and credited premise + +Let K be any field of characteristic two and let +R = K[Q]/(Q^2-1). The symbol Q is a formal central involution. +Fix n>0 target coordinates, h>=0 arbitrary dirty helper coordinates, +k>=3 available paid calls, and a nonnegative integer rank cap r. +Free gates are arbitrary constant matrices in GL_(n+h)(K). +A paid gate is I+Q N, where N is constant, N^2=0, and rank(N)<=r. +The complete required endpoint on every input is + +```text +diag(Q I_n, I_h). +``` + +Thus every original helper value must return unchanged, without a promise +on its value or correlations with the target inputs. +Put m_k=2 floor((k-1)/2). The endpoint is possible with at most k calls iff + +```text +n is even and n + ceil(n/m_k) <= k r. +``` + +Whenever feasible, its least total paid rank with at most k calls is +n+ceil(n/m_k). +Neither statement depends on h. Zero-rank calls may pad a shorter word. + +The new part is necessity for arbitrary h. Josie Elliston's +[PR #6138](https://github.com/CrocSwap/integer-mult-bounds/pull/6138), +`research/four-block-query-capacity-audit/README.md`, finding 5, supplies +the workspace-free attaining construction. We use that theorem as a cited +premise and extend its words by the identity on h helpers. We do not replay +its computations or claim its construction. Its four-call theorem credits +Nick Petalas #6122, its simplex credits Cinna Davis, its Gram framework +credits Ali Romman #5617, and its source question credits Matarener #6114. + +## 2. Normalize to a projection, keeping every helper + +Set epsilon=Q+1, so epsilon^2=0 and R=K[epsilon]/(epsilon^2). +For square-zero N, + +```text +I+Q N = (I+N)(I+epsilon N). +``` + +Move the constant factors and free gates to one side, conjugating the N's +by constant invertible matrices. Rank and square-zero are preserved. +The constant part of the required endpoint is I, so the complete endpoint +is equivalent to + +```text +sum_(i=1)^k R_i = P, +R_i^2=0, +P=diag(I_n,0_h). +``` + +All products involving two epsilon terms vanish. Conversely, such a sum +implements I+epsilon P by preceding each paid I+Q R_i with the free I+R_i. +This equivalence keeps the whole arbitrary-input matrix, including both +off-diagonal helper blocks. It does not discard helper information. + +Let r_i=rank(R_i) and S=sum r_i. Since a square-zero matrix has trace zero, +trace(P)=n times 1_K=0, so n must be even. + +## 3. The projection Gram complement + +Factor R_i=U_i V_i with U_i injective and V_i surjective through K^(r_i). +Then V_i U_i=0, since U_i(V_i U_i)V_i=R_i^2=0. +Concatenate the U_i horizontally into U and the V_i vertically into V. +Thus UV=P. Let + +```text +X=VU on K^S, Y=I_S+X, d=S-n. +``` + +The call-diagonal blocks of X vanish, so Y_ii=I_(r_i). +Although P is a projection, X need not be one. Instead, + +```text +X^3=V P^2 U=V P U=X^2, +Y^3=Y. +``` + +The fixed space of X has dimension n. Indeed, U and V restrict to inverse +maps between ker(I_S+X) and im(P). For Xv=v, P(Uv)=Uv and VUv=v. +For Pw=w, XVw=Vw and UVw=w. Therefore rank(Y)=S-n=d. + +Take a full-rank factorization Y=A B through K^d. Since Y^3=Y, +injectivity of A and surjectivity of B give + +```text +C=BA, C^2=I_d. +``` + +In particular C is invertible. Partition A into call row blocks A_i +and B into matching column blocks B_i. The call-diagonal equations give + +```text +A_i B_i=I_(r_i), +E_i=B_i A_i, E_i^2=E_i, rank(E_i)=r_i, +sum E_i=C. +``` + +Consequently r_i<=d. When h=0, the old argument can take C=I_d. +With dirty helpers, C can be a nonidentity involution I_d+Z with Z^2=0. +Invertibility, rather than identity, is the property needed below. + +## 4. The rank bound for every call count + +If k is odd, sum r_i<=k d immediately gives + +```text +(k-1) S >= k n, +S >= n + ceil(n/(k-1)). +``` + +If k is even, characteristic two gives sum(I_d+E_i)=C. +Each I_d+E_i has rank d-r_i, while C has rank d. Rank subadditivity yields + +```text +d <= sum(d-r_i) = k d-S, +(k-2) S >= (k-1) n, +S >= n + ceil(n/(k-2)). +``` + +Together these say S>=n+ceil(n/m_k). Since S<=k r, the stated uniform-cap +condition is necessary. The credited workspace-free construction proves +sufficiency and equality for total rank. This finishes the scoped theorem. + +For example, four rank-two paid calls cannot twist six independent +coordinates even when any number of arbitrary dirty helpers may be mixed +into every call and must eventually return unchanged. The new conclusion +is the independence from the helper count, not the predecessor's +workspace-free numerical bound. + +## 5. A genuine nilpotent defect and the clean-helper boundary + +Write binary matrices as integer-coded rows, with the least significant +bit the first column. The four three-by-three matrices + +```text +(0,6,6), (6,6,6), (0,5,0), (7,7,0) +``` + +are square-zero rank-one matrices with sum diag(1,1,0). Their stacked +X=VU is not idempotent, and the complement factor has C!=I but C^2=I. +The verifier reconstructs these facts without treating the coded rows as +a receipt. Thus replacing the predecessor's identity by a projection +requires the new argument in section 3. + +Initialized clean helpers have a different contract. The two-by-two terms + +```text +(2,0), (0,1), (3,3) +``` + +sum to I_2 and yield endpoint Q I_2. On (x,0) this twists one target and +returns the zero helper, despite n=1 being odd. On (x,y) it also twists y. +It therefore fails dirty restoration. The theorem does not cover a +zero-initialized helper promise, discarded outputs, nonlinear controls, +Q-dependent free gates, non-square-zero paid gates or approximate equality. + +This is an abstract query-capacity obstruction. Native implementation, +physical basis-change costs, independent stage multipliers, storage, +precision, a complete supplier invoice and the five selected framework +assumptions remain outside the claim. No new kappa or complete +multiplication theorem follows. The all-field proof is written mathematics; +finite binary checks do not provide formal proof-kernel acceptance. diff --git a/research/clean-query-rank-optimum/predecessor/PR6800-README.md b/research/clean-query-rank-optimum/predecessor/PR6800-README.md new file mode 100644 index 0000000000..8df37528f5 --- /dev/null +++ b/research/clean-query-rank-optimum/predecessor/PR6800-README.md @@ -0,0 +1,131 @@ +# Exact query capacity with restored dirty helpers + +This contribution was produced by Nick Petalas. Apache-2.0. + +**Scoped proof with exact finite corroboration; no new kappa.** An arbitrary +finite bank of restored dirty helpers cannot lower the square-zero query +capacity in characteristic two. This answers the dirty-workspace part of +Josie Elliston's [PR #6138](https://github.com/CrocSwap/integer-mult-bounds/pull/6138), +second Open next question. Its workspace-free attaining theorem is a cited +premise, not a replay target. + +Over any characteristic-two field K, let Q be a formal central involution. +Free gates are constant invertible matrices. Each paid gate is I+Q N with +N^2=0 and rank(N)<=r. There are n>0 independent targets and any h>=0 +independent dirty helpers. The full endpoint must be diag(Q I_n,I_h). +For k>=3 available calls and m_k=2 floor((k-1)/2), feasibility is exactly + +```text +n is even and n + ceil(n/m_k) <= k r. +``` + +Whenever feasible, the least total paid rank is n+ceil(n/m_k), independently of h. +For example, adding restored dirty helpers cannot make four rank-two calls +twist six independent targets. The same capacity without helpers was +already proved by #6138; the new result is its invariance under arbitrary +finite dirty workspace. + +[PROOF.md](PROOF.md) gives the all-field argument. Normalization replaces +an identity endpoint by a projection P. The call Gram matrix X then only +satisfies X^3=X^2. Factoring Y=I+X yields an invertible complement core C +with C^2=I, rather than C=I. Its diagonal blocks still give idempotents. +Rank subadditivity recovers the same even-call bound; a separate dimension +count gives the odd-call bound. A nonidentity core occurs in the finite +fixtures, so the identity-only predecessor argument cannot be reused +without this step. + +## Evidence and reproduction + +From the repository root, with the interpreter used locally: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/restored-dirty-query-capacity/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/restored-dirty-query-capacity/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/restored-dirty-query-capacity +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/restored-dirty-query-capacity --check-source-history +``` + +Elsewhere substitute a CPython 3.12 path. Only the standard library is +needed. The direct verifier emits `PASS_RESTORED_DIRTY_QUERY_CAPACITY` +in a generated JSON receipt bound to the six package files' SHA256 hashes. +It writes no files and imports no predecessor program. + +- A complete three-coordinate, four-call binary fixture uses two target + coordinates and one arbitrary restored dirty helper. Pair joins and a + separate direct scan of all 234,256 ordered four-tuples both find exactly + 648 valid words. The new complement identities hold for each, including + all 288 nonidentity cores. Literal quotient-ring execution checks all + eight dirty inputs of each word, for 5,184 executions. +- Padded dirty-helper fixtures exercise each call count from three through + eight, covering both parity branches of the new rank argument. +- A separate complete two-pair minimization on four coordinates, two targets + and two dirty helpers, gives minimum total rank three for caps one and + two. It includes respectively 11,236 and 99,856 ordered pairs and retains + every pair-sum cost. It does not enumerate all ordered four-tuples in this + larger domain. +- Four rejecting controls cover a non-square-zero summand with unchanged + total, the wrong complete endpoint, a nonprojection, and the enumeration + dimension limit. A literal clean-helper example shows why a zero-input + promise does not imply dirty restoration. + +The written proof, not these small fixtures, establishes arbitrary field, +helper count and dimension. No predecessor counts were replayed as the +contribution. [SOURCES.json](SOURCES.json) pins the source question and +attainment theorem as historical provenance at canonical main +`7c49fe32c55de02c2c873655c804b16e4c3fef0a`, priority revision 8. + +## Limits and expansion decision + +This theorem requires exact formal equality, constant free controls, +square-zero paid terms, and restoration of every arbitrary helper input. +Initialized clean helpers, discarded helper outputs, non-square-zero paid +operations, nonlinear controls and approximation remain outside its scope. +The clean-helper example in the proof can twist one target using three +rank-one calls and a clean zero helper, while its full dirty endpoint fails. + +There is no physical multi-bank query, native alignment, charged basis +implementation, stage chronology, complete signed invoice, compiler or +precision/tape construction. The five selected framework assumptions are +unchanged. No selected cold replay, Lean or Docker run, independent human +review or formal proof-kernel acceptance is claimed. + +This closes the restored-dirty-workspace route in this model. Further +construction work needs a changed hypothesis and a complete favorable +physical bill. A larger search inside the same dirty model is unnecessary. +The non-square-zero and initialized-clean alternatives remain open and +are not assigned by this package. + +Power of Ten rule 3 has a managed-runtime deviation. Python allocates +integers, tuples and dictionaries during verification. Scientific loops +have fixed bounds: dimension at most four, at most 65,536 candidate +matrices per census, 234,256 streamed raw four-tuples, and at most 65,536 +pair-sum keys. Gram fixtures use at most eight calls and matrices of width +at most eight. There is no recursion, network operation, subprocess or +dynamic code in the verifier. Every function is below 60 physical lines. +Warning-strict normal and optimized commands are registered. The deviation +is confined to this terminating verifier; any larger search must introduce +new capacity bounds before expanding it. + +## Open next questions + +- Can initialized clean helpers reduce the paid-rank floor for even target + dimensions? This would separate clean from restored dirty capacity beyond + the odd-dimension example. First classify the permitted unspecified + helper-column blocks in a normalized endpoint. The complete endpoint and + clean-return contract need to be fixed before claiming a capacity. +- Which invertible non-square-zero paid alphabet can improve a real caller? + This is the remaining distinct branch of #6138's second question. First + specify a native gate, its complete arbitrary-input response and paid + rank. No such physical gate or profitable invoice is supplied here. + +## Credit + +Josie Elliston's #6138 supplies the question, all-call workspace-free +attainment theorem and its stated unresolved workspace boundary. Credit +Nick Petalas #6122 for the earlier four-call theorem, Cinna Davis for the +rank-one simplex and controller lineage, Ali Romman #5617 for the coupled +Gram framework and block simplex, and Matarener #6114 for the higher-rank +query question. Rank factorization, kernel correspondence and rank +subadditivity are standard linear algebra. The new contribution is the +projection-complement involution argument and the resulting sharp +restored-dirty-workspace exclusion. No predecessor credit line is changed. diff --git a/research/clean-query-rank-optimum/predecessor/PR6808-PROOF.md b/research/clean-query-rank-optimum/predecessor/PR6808-PROOF.md new file mode 100644 index 0000000000..e6b8c65406 --- /dev/null +++ b/research/clean-query-rank-optimum/predecessor/PR6808-PROOF.md @@ -0,0 +1,176 @@ +# Two clean helpers suffice, and are necessary, for the six-target case + +Prepared for ToikY with substantial source-aware OpenAI Codex assistance. +Apache-2.0. The dirty-capacity theorem, normalization and Gram lineage of +Nick Petalas6800 and its credited predecessors retain attribution below. + +## 1. Exact statement and changed promise + +Let K be any field of characteristic two and R=K[Q]/(Q²−1), with Q a +formal central involution. Constant invertible matrices over K are free. +A paid gate is I+QN, where N is constant, N²=0 and rank(N)≤2. +There are six public coordinates, h helpers and at most four paid gates. +Require precisely + + W(x,0)=(Qx,0) for every x in R^6. + +Helpers start at zero and return to zero; arbitrary old helper values need +not return. Under this promise the least possible h is exactly two. +The construction uses four rank-two paid gates, total paid rank eight. +We do NOT assert eight is the least total paid rank with clean helpers. + +Nick Petalas6800 proves that restored arbitrary DIRTY helpers cannot lower +the corresponding total-rank floor nine. Its even-clean question is open +in the pinned source. The new result answers this fixed six-target case, +including its minimum helper count. It changes the entrance promise and +does not contradict or reprice the dirty theorem. All dimensions, ranks +and costs here belong to the stated abstract linear query model. + +## 2. Four square-zero summands + +Use four blocks K², for a total of eight scalar coordinates. Let J be the +4-by-4 block matrix every block of which is I₂, and put P=I₈+J. +Since four is zero in K, J²=0 and P²=I₈. The diagonal blocks of P vanish; +its off-diagonal blocks equal I₂. + +For i=1,2,3,4, let U_i:K²→K⁸ embed into block i and let V_i:K⁸→K² be +block row i of P. Set R_i=U_i V_i. Then V_i U_i=0, so R_i²=0. +V_i is surjective (any one of its other three blocks is I₂), and U_i is +injective, so rank(R_i)=2 over every K. Summing block rows gives + + R_1+R_2+R_3+R_4=P. + +This is a block all-ones/rank-factorization construction, using classical +linear algebra and the credited simplex/Gram viewpoint, not a new query +alphabet or an uncharged physical gate implementation. + +## 3. Literal query word and its complete operator + +Set ε=1+Q. Then ε²=0 in R. Since R_i²=0, + + (I+R_i)(I+Q R_i)=I+ε R_i. + +Each such factor uses one allowed constant free gate and one paid gate. +The free gate is invertible with inverse itself. The paid gate is likewise +its own inverse. Products of two ε terms vanish, hence in any order + + product_i (I+R_i)(I+Q R_i)=I+εP. + +For public blocks x₁,x₂,x₃ in K² and a helper block h in K², define the +constant free basis + + C(x₁,x₂,x₃,h)=(x₁,x₂,x₃,x₁+x₂+x₃+h). + +C²=I. The block sum of C(x,h) is h, so J C(x,h)=(h,h,h,h). +It follows directly, on ALL inputs, that + + C⁻¹ P C(x₁,x₂,x₃,h)=(x₁+h,x₂+h,x₃+h,h). + +Let L be the 6-by-2 matrix obtained by stacking three copies of I₂. +The literal word applies C, the four free/paid pairs, then C⁻¹. Its full +R-linear matrix is + + W=C⁻¹(I+εP)C = [ Q I₆ εL ] + [ 0 Q I₂ ]. + +Thus W(x,0)=(Qx,0), as required, for every formal-ring x. All six public +columns and both unspecified helper columns have been stated, not just +tested on a chosen set of numerical inputs. W²=I because ε²=0 and the +characteristic is two, so the inverse restriction is identical. The +reversed literal word also supplies the inverse using allowed gates. + +There are exactly four paid gates of rank two and six free basis gates: +four I+R_i factors plus C and C⁻¹. No physical tariff is assigned to those +free bases or to preparation/ownership of the zero helpers. + +## 4. Why arbitrary dirty restoration fails + +For x=0 and h=(1,0), the output helper is (Q,0), rather than (1,0), and +each public block acquires (ε,0). Both differences are nonzero in the +formal ring. In particular the complete matrix is not diag(QI₆,I₂). +Numerically substituting Q=1 would erase exactly this distinction and is +not a test of the formal endpoint. The derivative coefficient +C⁻¹PC=[I₆,L;0,I₂] is an involution, but is not a projection: its square +is I₈ and L≠0. Applying the source's projection bound to it would discard +the clean/dirty boundary. + +## 5. No word with zero or one helper can satisfy the clean promise + +Consider ANY permitted word with h≤1, including arbitrary constant free +gates and at most four square-zero paid terms of rank at most two. +The following normalization is the one credited in source6800; here its +constant endpoint need only fix the public subspace pointwise. + +Evaluate ε=0 (equivalently Q=1) and call the constant word A. A is +invertible, and the clean promise implies A(x,0)=(x,0). Its free inverse +also fixes that subspace. Therefore replacing W by A⁻¹W preserves the +clean promise and uses no additional paid gate. + +Move all constant factors to one side, using +I+QN=(I+N)(I+εN). Conjugation by constants preserves rank and square-zero. +The normalized full matrix is I+εD, where + + D=sum_i T_i, T_i²=0, rank(T_i)≤2, + +with at most four terms. Every square-zero matrix has trace zero, hence +trace(D)=0. The clean public-column identity gives D(x,0)=(x,0). + +If h=0, D=I₆ and the full endpoint is QI₆. If h=1, for some column b +and scalar d in K the FULL coefficient is + + D=[I₆ b] + [ 0 d]. + +Since six is zero in K, trace(D)=d=0. Consequently D²=D and rank(D)=6. +The constant public-fixing shear S=[I₆,b;0,1], with S²=I, conjugates D +to diag(I₆,0). After this allowed free conjugation the normalized word +has full arbitrary-input endpoint diag(QI₆,1): it is a restored DIRTY +word with the same at-most-four paid gates and the same rank cap. + +Source6800's credited dirty-capacity necessity applies. For k=4 its +m_k=2 and six public coordinates require + + total paid rank ≥ 6+ceil(6/2)=9. + +The candidate word has total paid rank at most 4·2=8, a contradiction. +The same source theorem excludes h=0. Zero-rank padding covers words +using fewer than four gates. This proves h≥2; Section3 attains h=2. + +The new lower-bound step is the one-helper trace/projection reduction. +The dirty floor and its projection-complement proof are source6800's +work, cited rather than a new census or an independent re-certification. +The displayed reduction checks its exact hypotheses; it does not assume +that an arbitrary clean endpoint with two or more helpers is a projection. + +## 6. Evidence and limits + +This is an all-field written proof, not a proof-kernel certificate. +The new verifier is finite corroboration of the explicit word, complete +formal endpoint, inverse and premise-removal controls. Its exact executed +domains/counts are reported by generated receipts and the README after +observation. It imports and executes no predecessor scientific program. +Finite checks alone do not prove all-field feasibility or the universal +minimum-helper claim; the argument above supplies those implications. + +Initialized helper preparation, ownership, basis implementation, native +alignment, actual caller chronology, retention/restoration costs and the +complete signed supplier invoice remain separate obligations. This is no +physical saving, supplier admission, κ improvement or selected-frontier +change. All five selected assumptions remain. No general clean-capacity +classification, total-paid-rank optimum, human acceptance or formal-kernel +verification is asserted. The original native-conversion task gate is +unmet; the catalogue scope is explicitly changed and its outcome partial. + +## 7. Predecessor credit + +Nick Petalas6800 supplies the dirty theorem, projection-complement +normalization, clean-versus-dirty distinction and explicit even-clean +question. Josie Elliston6138 supplies its earlier workspace-free theorem +and workspace question; Nick6122, Cinna Davis's simplex/controller line, +Ali Romman5617's coupled Gram/block simplex and Matarener6114 retain credit. +Rank factorization, dual-number linearization, block all-ones matrices, +trace and constant shear conjugation are classical. Exact retained source +texts and their immutable foreign commit/blob/SHA pins accompany this note. +Substantial OpenAI Codex proposal, implementation, source-aware challenge, +overlap and metadata roles share source context; they are not blind or +independent human/proof-kernel acceptance. diff --git a/research/clean-query-rank-optimum/predecessor/PR6808-README.md b/research/clean-query-rank-optimum/predecessor/PR6808-README.md new file mode 100644 index 0000000000..4da5299228 --- /dev/null +++ b/research/clean-query-rank-optimum/predecessor/PR6808-README.md @@ -0,0 +1,47 @@ +# Two clean helpers for six formal query targets + +**Scoped written proof with exact finite corroboration; no new kappa.** This answers the fixed six-target initialized-clean question released by Nick Petalas [PR6800](https://github.com/CrocSwap/integer-mult-bounds/pull/6800): four rank-two square-zero calls suffice with two initialized helpers returned to zero, and two is the least helper count under those fixed call/rank caps. The minimum-helper argument uses the credited dirty theorem and a new one-helper trace/projection reduction. + +Over any characteristic-two field K, use the formal ring R=K[Q]/(Q²−1), constant free bases in GL8(K), and at most four paid gates I+Q N with N²=0 and whole-matrix rank(N)≤2. Six data coordinates are arbitrary; two helpers begin at zero and must return zero. The complete operator is + +```text +W = [[Q I6, (1+Q)L], [0, Q I2]], L = [I2; I2; I2]. +``` + +Thus W(x,0)=(Qx,0). The helper columns are part of the stated full operator: arbitrary dirty restoration fails (for example, the constant helper(1,0)). Requiring diag(QI6,I2) instead would silently return to6800's excluded dirty model. Q is a formal nontrivial central symbol, not an identity substitution. + +The word uses four rank-two calls, total paid rank8. **No total paid-rank optimality is claimed.** The helper lower bound is only for n6, at most four calls and rank cap2: zero or one clean helper is reduced by a trace/projection argument to the credited6800 dirty floor9. This needs the written argument, not a failed finite search. See [PROOF.md](PROOF.md). + +## Evidence and runtime boundary + +The first new-verifier replay passed on CPython3.12.14 in1.364seconds with20.97MiB peak resident memory, empty stderr and unchanged package hashes. These measurements check the stated budget, not a speedup against a predecessor. The new standard-library verifier uses no runtime Git, network, subprocess or predecessor-code import. Registered normal/optimized caps are120seconds each. + +- Ordered pair-polynomial matrix multiplication checks every paid whole-matrix rank/square-zero condition, all ten literal paid/free gates, the complete operator and reversed inverse word. +- A separate component-gate interpreter checks all65,536vectors of (F2[Q]/(Q²−1))^8, including all4,096zero-helper entrances:65,536forward,65,536reverse and131,072round-trip compositions. The exhaustive loop executes262,144literal words; prechecks and controls are additional executions. Its profile SHA256 is `aca44f95b5664b09d8baaf741721d05d8fca6bd4807b2edf837514514b4e3290`. +- All64binary one-helper columns pass the projection/shear reduction and scalar-trace controls. This corroborates the written reduction, not an all-word exclusion or an all-field enumeration. +- Eight controls enforce their intended rejection reason; six retain actual unequal endpoint witnesses. They distinguish invalid paid terms, missing bases/cleanup/calls, wrong endpoints, collapsing formalQ to1 and falsely extending to dirty restoration. + +The all-field construction and universal helper-minimum claim rest on the written proof and credited6800floor9, not finite testing alone. Source-aware proof and code challenges are not blind, human or proof-kernel acceptance. Final normal/optimized registered, committed-byte/export/publication and hosted-CI checks are separate delivery observations recorded in the PR/handoff when completed. Every replay emits generated receipts binding all package hashes. + +```sh +python3.12 -I -B research/clean-two-helper-query/verify.py +python3.12 -I -O -B research/clean-two-helper-query/verify.py +python3.12 -B scripts/research_package.py --package research/clean-two-helper-query +``` + +The complete original card and CHANGED/partial scope are in [TASK.json](TASK.json). [SOURCES.json](SOURCES.json) pins canonical catalogue/selected provenance only. Exact6800PROOF/README bytes in [SOURCE-PINS.json](SOURCE-PINS.json) are retained mathematical provenance, not executable predecessors. Runtime vendor inputs are package-local, so external VERIFY.inputs is empty. No selected construction or historical scientific replay is requested. + +## Distinct source contracts and credit + +6800proves that arbitrary restored dirty helpers do not improve capacity and explicitly leaves initialized-clean EVEN targets open; its existing odd n1example is not new here. Josie Elliston6138 supplies workspace-free capacity/attainment and the first n6four-rank2exclusion; Nick Petalas6122 supplies the earlier four-call Gram bound. Their results are credited inputs, not rerun. + +JoyboyBrian5007and Petalas5857already supply clean square-zero COUPLING compilation and primitive lowering, using rank-one IDEMPOTENT reflections. Their alphabet/target differs from I+Q N with square-zero N and target QI6. The card's1974GL3census and2027UT4mixed-root tariffs were compared as distinct noncentral/multilabel rank-one and restored-dirty models; no count or tariff is transferred. [CREDITS.md](CREDITS.md), [NOTICE](NOTICE) and [LICENSE](LICENSE) retain attribution. + +## Limits + +This is an abstract clean-return model, with free bases and initialized helper roles explicitly counted. It supplies no clean preparation/reservation price, physical basis implementation, native conversion, actual caller, complete invoice or full supplier. It does not justify another family expansion/search. All five selected assumptions remain; no kappa, frontier, merge, human or proof-kernel acceptance is claimed. Source-aware future/proposal exposure and substantial OpenAI Codex assistance are disclosed; this is not blind discovery or independent-end-to-end verification. + +## Open next questions + +1. **Bind one native caller and full bill.** Specify the central operator, each paid rank-two map, both basis conversions, clean preparation/return and every movement/precision/storage cost. Native contracts and a complete invoice are missing. +2. **Separate total-rank optimality from helper minimality.** Fix the same alphabet and complete allowed helper-column contract before deriving any paid-rank optimum. This one rank8word is not such a lower bound; no broader search is reserved. diff --git a/research/clean-query-rank-optimum/verify.py b/research/clean-query-rank-optimum/verify.py new file mode 100644 index 0000000000..3e75305890 --- /dev/null +++ b/research/clean-query-rank-optimum/verify.py @@ -0,0 +1,472 @@ +"""New finite fixed-subspace rank certificates and tiny actual-query fixtures. + +Only predecessor prose is authenticated. No PR6808 eight-role attaining word, +constructor, checker or source program is loaded or executed. Small matrices +may coincide with values occurring in predecessor examples. +""" +from itertools import product +import hashlib +import json +from pathlib import Path +import sys + +PACKAGE = Path(__file__).resolve().parent +MANIFEST_SHA = 'f6745060beaa1617ef8256b2211feed75554cd652b713d54f40addf2b5f69b29' +PATHS = {'predecessor/PR6808-README.md', 'predecessor/PR6808-PROOF.md', + 'predecessor/PR6800-README.md', 'predecessor/PR6800-PROOF.md'} + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def unique(pairs): + result = {} + for key, value in pairs: + require(key not in result, 'duplicate JSON key') + result[key] = value + return result + + +def no_number(text): + raise ValueError('noninteger JSON number') + + +def load(raw): + return json.loads(raw, object_pairs_hook=unique, parse_float=no_number, parse_constant=no_number) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True, allow_nan=False).encode() + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def authenticate(): + raw = (PACKAGE / 'SOURCE-PINS.json').read_bytes() + require(hashlib.sha256(raw).hexdigest() == MANIFEST_SHA, 'source manifest bytes') + pins = load(raw) + require(type(pins['schema_version']) is int and pins['schema_version'] == 1, 'source schema') + require(len(pins['files']) == 4 and {x['local_path'] for x in pins['files']} == PATHS, 'source inventory') + result = {} + for row in pins['files']: + path = PACKAGE / row['local_path'] + require(path.is_file() and not path.is_symlink(), 'source regular file') + data = path.read_bytes() + blob = hashlib.sha1(b'blob '+str(len(data)).encode()+b'\0'+data).hexdigest() + require((len(data), hashlib.sha256(data).hexdigest(), blob) == + (row['bytes'], row['sha256'], row['git_blob']) and row['mode'] == '100644', 'source bytes') + result[row['local_path']] = row['sha256'] + return result + + +def zero(rows, columns): + return [[0]*columns for _ in range(rows)] + + +def identity(size): + return [[int(i == j) for j in range(size)] for i in range(size)] + + +def add(left, right, field, sign=1): + require(len(left) == len(right), 'matrix row shape') + require(all(len(a) == len(b) for a, b in zip(left, right)), 'matrix column shape') + return [[(a+sign*b) % field for a, b in zip(ar, br)] for ar, br in zip(left, right)] + + +def multiply(left, right, field, columns=None): + require(all(len(row) == len(right) for row in left), 'matrix product shape') + width = len(right[0]) if right else (0 if columns is None else columns) + require(all(len(row) == width for row in right), 'rectangular right matrix') + result = zero(len(left), width) + for i, row in enumerate(left): + for k, scalar in enumerate(row): + if scalar: + for j, other in enumerate(right[k]): + result[i][j] = (result[i][j] + scalar*other) % field + return result + + +def rref(matrix, field): + work = [[x % field for x in row] for row in matrix] + height, width = len(work), len(work[0]) if work else 0 + pivots = [] + for column in range(width): + row = len(pivots) + pivot = next((i for i in range(row, height) if work[i][column]), None) + if pivot is None: + continue + work[row], work[pivot] = work[pivot], work[row] + scale = pow(work[row][column], field-2, field) + work[row] = [(x*scale) % field for x in work[row]] + for i in range(height): + if i != row and work[i][column]: + scale = work[i][column] + work[i] = [(x-scale*y) % field for x, y in zip(work[i], work[row])] + pivots.append(column) + if len(pivots) == height: + break + return work, pivots + + +def rank(matrix, field): + return len(rref(matrix, field)[1]) + + +def nullspace(matrix, field): + work, pivots = rref(matrix, field) + width = len(matrix[0]) if matrix else 0 + vectors = [] + for free in range(width): + if free in pivots: + continue + vector = [0]*width + vector[free] = 1 + for row, column in enumerate(pivots): + vector[column] = -work[row][free] % field + vectors.append(vector) + return [[vector[i] for vector in vectors] for i in range(width)] + + +def inverse(matrix, field): + size = len(matrix) + extended = [row[:] + tail for row, tail in zip(matrix, identity(size))] + reduced, pivots = rref(extended, field) + require(pivots[:size] == list(range(size)), 'singular ordinary scalar map') + result = [row[size:] for row in reduced] + require(multiply(matrix, result, field) == multiply(result, matrix, field) == identity(size), + 'ordinary scalar inverse') + return result + + +def factor(matrix, field): + _, pivots = rref(matrix, field) + amount = len(pivots) + u = [[row[j] for j in pivots] for row in matrix] + if amount == 0: + v = [] + elif amount == 1: + row = next(i for i in range(2) if u[i][0]) + scale = pow(u[row][0], field-2, field) + v = [[x*scale % field for x in matrix[row]]] + else: + v = multiply(inverse(u, field), matrix, field) + require(multiply(u, v, field, columns=2) == matrix, 'rank factor product') + require(rank(u, field) == rank(v, field) == amount, 'full rank factors') + return amount, u, v + + +def square_zero(matrix, field): + require(len(matrix) == 2 and all(len(row) == 2 for row in matrix), 'two-role shape') + require(all(type(x) is int and 0 <= x < field for row in matrix for x in row), 'field entries') + require(multiply(matrix, matrix, field) == zero(2, 2), 'coupling is not square zero') + + +def sum_matrices(matrices, field): + result = zero(2, 2) + for matrix in matrices: + result = add(result, matrix, field) + return result + + +def lemma(matrices, field, factors=None): + if factors is None: + factors = [] + for matrix in matrices: + square_zero(matrix, field) + factors.append(factor(matrix, field)) + else: + require(len(matrices) == len(factors), 'factor inventory') + total = sum_matrices(matrices, field) + amounts = [item[0] for item in factors] + volume, maximum = sum(amounts), max(amounts, default=0) + u = [sum((item[1][row] for item in factors), []) for row in range(2)] + v = [row[:] for _, _, block in factors for row in block] + require(multiply(u, v, field, columns=2) == total, 'global M equals UV') + e = multiply(v, u, field) + start = 0 + for amount, local_u, local_v in factors: + require(multiply(local_v, local_u, field) == zero(amount, amount), 'ViUi not zero') + require([row[start:start+amount] for row in e[start:start+amount]] == zero(amount, amount), + 'E diagonal block not zero') + start += amount + basis = nullspace(add(total, identity(2), field, -1), field) + dimension = len(basis[0]) + require(rank(basis, field) == dimension and multiply(total, basis, field) == basis, 'full fixed space') + image = multiply(v, basis, field) + require(rank(image, field) == dimension, 'V not injective on fixed space') + require(multiply(e, image, field) == image, 'E does not fix V(P)') + defect = add(identity(volume), e, field, -1) + defect_rank = rank(defect, field) + require(maximum <= defect_rank <= volume-dimension, 'identity-diagonal rank sandwich') + require(volume >= dimension+maximum, 'fixed-subspace rank lower bound') + return dict(R=volume, d=dimension, maximum_rank=maximum, rank_I_minus_E=defect_rank, + fixed_basis=basis, M=total, E=e, + M_is_projection=multiply(total, total, field) == total) + + +def square_zero_matrices(field): + matrices, factors = [], [] + for cells in product(range(field), repeat=4): + matrix = [list(cells[:2]), list(cells[2:])] + if multiply(matrix, matrix, field) == zero(2, 2): + square_zero(matrix, field) + matrices.append(matrix) + factors.append(factor(matrix, field)) + require(matrices and zero(2, 2) in matrices, 'zero-padding inventory') + return matrices, factors + + +def enumerate_lemma(field, maximum_slots): + matrices, factors = square_zero_matrices(field) + histogram, cases, nonprojective_fixed = {}, 0, 0 + certificate_digest = hashlib.sha256() + for slots in range(maximum_slots+1): + for indices in product(range(len(matrices)), repeat=slots): + selected = [matrices[i] for i in indices] + result = lemma(selected, field, [factors[i] for i in indices]) + paid_count = sum(factors[i][0] > 0 for i in indices) + key = '/'.join(str(x) for x in (slots, paid_count, result['R'], result['d'], result['maximum_rank'])) + histogram[key] = histogram.get(key, 0)+1 + nonprojective_fixed += int(result['d'] > 0 and not result['M_is_projection']) + certificate_digest.update(canonical(dict(indices=indices, certificate=result))+b'\n') + cases += 1 + return dict(field=field, scalar_roles=2, square_zero_matrices=len(matrices), maximum_slots=maximum_slots, + ordered_tuple_cases=cases, zero_is_padding_not_paid=True, + histogram_axes=['slots', 'nonzero_paid_summands', 'R', 'fixed_dimension', 'maximum_rank'], + histogram=histogram, nonprojection_with_nonzero_fixed_space=nonprojective_fixed, + certificate_sha256=certificate_digest.hexdigest()) + + +def rank_two_block_fixture(field): + """One four-role classical block fixture, not the six-target attaining word.""" + u1 = [[1, 0], [0, 1], [0, 0], [0, 0]] + v1 = [[0, 0, 1, 0], [0, 0, 0, 1]] + u2 = [[0, 0], [0, 0], [1, 0], [0, 1]] + v2 = [[1, 0, 0, 0], [0, 1, 0, 0]] + summands = [] + for u, v in ((u1, v1), (u2, v2)): + n = multiply(u, v, field) + require(rank(u, field) == rank(v, field) == rank(n, field) == 2, + 'rank-two block full-rank factor') + require(multiply(v, u, field) == zero(2, 2), 'rank-two block ViUi') + require(multiply(n, n, field) == zero(4, 4), 'rank-two block square zero') + summands.append(n) + u = [left+right for left, right in zip(u1, u2)] + v = v1+v2 + m = add(summands[0], summands[1], field) + require(multiply(u, v, field) == m, 'rank-two block M equals UV') + e = multiply(v, u, field) + for start in (0, 2): + require([row[start:start+2] for row in e[start:start+2]] == zero(2, 2), + 'rank-two block E diagonal') + basis = nullspace(add(m, identity(4), field, -1), field) + require(len(basis[0]) == rank(basis, field) == 2, 'rank-two block full fixed dimension') + image = multiply(v, basis, field) + require(multiply(m, basis, field) == basis and rank(image, field) == 2, + 'rank-two block fixed-space injection') + require(multiply(e, image, field) == image, 'rank-two block E fixes V(P)') + defect_rank = rank(add(identity(4), e, field, -1), field) + volume, dimension = len(e), len(basis[0]) + maximum = max(rank(n, field) for n in summands) + require(maximum <= defect_rank <= volume-dimension and volume == dimension+maximum, + 'rank-two block sandwich equality') + require(multiply(m, m, field) != m, 'rank-two block nonprojection') + return dict(field=field, scalar_roles=4, summand_ranks=[2, 2], R=4, fixed_dimension=2, + maximum_rank=2, rank_I_minus_E=defect_rank, summands=summands, + U=u, V=v, E=e, M=m, fixed_basis=basis, M_is_projection=False, + scope='One classical A tensor I2 / B tensor I2 factorization fixture.') + + +def ring_product(left, right): + a, b = left + c, d = right + return (add(multiply(a, c, 2), multiply(b, d, 2), 2), + add(multiply(a, d, 2), multiply(b, c, 2), 2)) + + +def ordinary(matrix): + return matrix, zero(2, 2) + + +def actual_paid(matrix): + square_zero(matrix, 2) + require(rank(matrix, 2) > 0, 'zero omitted from nonzero paid count') + return identity(2), matrix + + +def validate_free(pair): + constant, query = pair + require(query == zero(2, 2), 'Q-dependent free gate') + require(rank(constant, 2) == 2, 'singular ordinary scalar map') + + +def conjugated(matrix, change): + return multiply(multiply(inverse(change, 2), matrix, 2), change, 2) + + +def clean_endpoint(pair, basis): + constant, query = pair + require(multiply(constant, basis, 2) == zero(2, len(basis[0])) + and multiply(query, basis, 2) == basis, 'not a complete clean-column endpoint') + + +def normalize(instructions): + actual, c, summands, paid_ranks = ordinary(identity(2)), identity(2), [], [] + step_digest = hashlib.sha256() + for kind, data in instructions: + if kind == 'free': + validate_free(data) + change = data[0] + factor_ring = data + else: + require(kind == 'paid', 'instruction kind') + factor_ring = actual_paid(data) + change = add(identity(2), data, 2) + actual = ring_product(actual, factor_ring) + summands = [conjugated(n, change) for n in summands] + if kind == 'paid': + summands.append(data) + paid_ranks.append(rank(data, 2)) + c = multiply(c, change, 2) + require(rank(c, 2) == 2, 'normalization constant invertibility') + for n in summands: + square_zero(n, 2) + require([rank(n, 2) for n in summands] == paid_ranks, 'conjugation rank preservation') + m = sum_matrices(summands, 2) + expected = (multiply(c, add(identity(2), m, 2), 2), multiply(c, m, 2)) + require(actual == expected, 'actual I+QN absorption/normalization') + require(multiply(inverse(c, 2), actual[1], 2) == m, 'coefficient-derived normalized M') + step_digest.update(canonical(dict(kind=kind, actual=actual, C=c, M=m))+b'\n') + certificate = lemma(summands, 2) + clean = nullspace(actual[0] + add(actual[1], identity(2), 2, -1), 2) + clean_endpoint(actual, clean) + require(multiply(c, clean, 2) == clean and multiply(certificate['M'], clean, 2) == clean, + 'clean columns imply C and M fix P') + require(certificate['R'] >= len(clean[0])+certificate['maximum_rank'], 'actual clean rank bound') + return actual, c, certificate, clean, step_digest.hexdigest(), paid_ranks + + +def normalization_fixtures(): + matrices, _ = square_zero_matrices(2) + nonzero = [n for n in matrices if rank(n, 2)] + scalars = [] + for cells in product(range(2), repeat=4): + matrix = [list(cells[:2]), list(cells[2:])] + if rank(matrix, 2) == 2: + scalars.append(matrix) + swap = [[0, 1], [1, 0]] + rows, steps, paid_calls = [], 0, 0 + for g, first, second in product(scalars, nonzero, nonzero): + instructions = [('free', ordinary(g)), ('paid', first), ('free', ordinary(swap)), + ('paid', second), ('free', ordinary(inverse(g, 2)))] + actual, c, cert, clean, trace_hash, ranks = normalize(instructions) + rows.append(dict(word_sha256=digest(instructions), complete_ring_sha256=digest(actual), + C=c, M=cert['M'], normalized_ranks=ranks, + full_fixed_dimension=cert['d'], actual_clean_dimension=len(clean[0]), + step_sha256=trace_hash)) + steps += len(instructions) + paid_calls += len(ranks) + return dict(field=2, ring='F2[Q]/(Q^2-1)', scalar_roles=2, + new_literal_words=len(rows), actual_instruction_steps=steps, + actual_nonzero_paid_instructions=paid_calls, words=rows, + scope='New tiny actual-alphabet normalization fixtures; no old six-target attaining word.') + + +def rejected(name, callback, reason, witness): + try: + callback() + except ValueError as error: + require(str(error) == reason, 'wrong control rejection: '+name) + return dict(name=name, outcome='REJECTED_FOR_INTENDED_REASON', reason=reason, witness=witness) + raise ValueError('control accepted: '+name) + + +def require_projection(matrix): + require(multiply(matrix, matrix, 2) == matrix, 'false extra projection assumption') + + +def controls(): + unit = identity(2) + fixed = nullspace(add(unit, identity(2), 2, -1), 2) + first = rejected('non_square_zero_identity', lambda: lemma([unit], 2), 'coupling is not square zero', + dict(N=unit, square=multiply(unit, unit, 2), rank=rank(unit, 2), + fixed_dimension=len(fixed[0]), false_R=2, false_required=4)) + n3, public = [[1, 1], [1, 1]], [[1], [0]] + leak_word = [('free', ordinary(add(unit, n3, 2))), ('paid', n3)] + actual, c, cert, _, _, _ = normalize(leak_word) + require(actual[0][0][0] == 0 and actual[1][0][0] == 1, 'payload-only Q witness') + target_pair = ([[0, 0], [0, 1]], [[1, 0], [0, 0]]) + require(add(*actual, 2) == add(*target_pair, 2) == identity(2), 'Q=1 collapse witness') + second = rejected('payload_only_helper_leak_and_Q1_collapse', lambda: clean_endpoint(actual, public), + 'not a complete clean-column endpoint', + dict(actual=actual, public_column=public, helper_constant=actual[0][1][0], + helper_Q=actual[1][1][0], Q1_actual=add(*actual, 2), Q1_target=add(*target_pair, 2))) + n1 = [[0, 1], [0, 0]] + swap = [[0, 1], [1, 0]] + n1 = conjugated(n1, swap) + word = [('free', ordinary(add(unit, n1, 2))), ('paid', n1), + ('free', ordinary(add(unit, n3, 2))), ('paid', n3)] + genuine, c, cert, clean, _, _ = normalize(word) + clean_endpoint(genuine, public) + require(c == unit and cert['d'] == 1 and not cert['M_is_projection'], 'genuine clean nonprojection') + third = rejected('projection_assumption_excludes_legal_clean_case', lambda: require_projection(cert['M']), + 'false extra projection assumption', + dict(M=cert['M'], square=multiply(cert['M'], cert['M'], 2), actual_word=word, + public_column=public, clean_dimension=len(clean[0]), rank_certificate=cert)) + fourth = rejected('Q_dependent_free_gate', lambda: normalize([('free', target_pair)]), 'Q-dependent free gate', + dict(forbidden_free_pair=target_pair, actual_clean_public_column=public)) + fifth = rejected('zero_paid_counting_convention', lambda: actual_paid(zero(2, 2)), 'zero omitted from nonzero paid count', + dict(N=zero(2, 2), scope='Legal identity padding is omitted from the canonical nonzero paid count; not a forbidden source-model gate.')) + return [first, second, third, fourth, fifth] + + +def profile_necessity(): + surviving = [] + for ranks in product(range(3), repeat=4): + volume, maximum = sum(ranks), max(ranks) + if volume >= 6+maximum: + surviving.append(list(ranks)) + require(surviving == [[2, 2, 2, 2]], 'six-target at-most-four rank profiles') + return dict(productive_dimension=6, call_limit=4, rank_cap=2, padded_profiles_checked=3**4, + necessary_profiles=surviving, necessary_total_rank=8, + attainment='Cited PR6808 rank8 witness; its word/data/constructor/verifier is not replayed.', + higher_call_counts='Outside this optimum statement.') + + +def parser_controls(): + return [rejected('duplicate_JSON', lambda: load('{"x":1,"x":1}'), 'duplicate JSON key', {'input':'duplicate key'}), + rejected('floating_JSON', lambda: load('{"x":1.0}'), 'noninteger JSON number', {'input':'1.0'}), + rejected('nonfinite_JSON', lambda: load('{"x":NaN}'), 'noninteger JSON number', {'input':'NaN'})] + + +def calculate(): + sources = authenticate() + return dict(status='PASS_CLEAN_FIXED_SUBSPACE_RANK_BOUND', schema_version=1, source_sha256=sources, + algebraic_rank_cases=[enumerate_lemma(2, 4), enumerate_lemma(3, 4), enumerate_lemma(5, 3)], + rank_two_block_fixtures=[rank_two_block_fixture(p) for p in (2, 3, 5)], + actual_F2_normalization=normalization_fixtures(), mathematical_controls=controls(), + parser_controls=parser_controls(), rank_profile_necessity=profile_necessity(), + source_programs_executed=False, + overlap_disclosure='Tiny2x2matrixvalues may coincide with predecessor examples; no old6808eight-roleattainer runs.', + scope='All-field fixed-subspace lemma corroboration plus F2 actual-query reduction; no higher-call/global classification.') + + +def main(): + require(sys.argv[1:] in ([], ['--emit']), 'only optional --emit is supported') + packet = calculate() + if not sys.argv[1:]: + require(canonical(load((PACKAGE / 'RESULT.json').read_bytes())) == canonical(packet), + 'retained complete result mismatch') + print(canonical(packet).decode()) + + +if __name__ == '__main__': + try: + main() + except (ValueError, KeyError, TypeError, OSError, json.JSONDecodeError) as error: + print('FAIL_CLEAN_FIXED_SUBSPACE_RANK_BOUND: '+str(error), file=sys.stderr) + raise SystemExit(1)