diff --git a/research/clifford-quadratic-orbit-blocks/LICENSE b/research/clifford-quadratic-orbit-blocks/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/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/clifford-quadratic-orbit-blocks/NOTICE b/research/clifford-quadratic-orbit-blocks/NOTICE new file mode 100644 index 0000000000..b4b11b284c --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/NOTICE @@ -0,0 +1,5 @@ +Prepared for ToikY with substantial source-aware OpenAI Codex assistance. Apache-2.0. + +Nick Petalas PR6794 supplies the transvection conditioning framework, exact807 relaxation and actual-stabilizer/spectrum request. alephnan PR6714 supplies the Gaussian-dyadic group conventions, width-nine multiplicities, Pauli-quadratic orbits, tensor reciprocity and Gram-block formula. Lee-Yu-Peng-Lai supply the published character table retained through these sources. Ali Romman, MatShep and the retained Clifford/full-group/stabilizer lineage keep their credit. Own excluded PR6718/6822 prior review and second-class relaxation are not recounted. + +Bell-matrix vectorization, Pauli weight spaces, symmetric/exterior powers, quadratic-form permutation actions, transvections, character orthogonality and tensor reciprocity are classical. No new general representation method is claimed. Exact source prose/data and external attribution are retained in SOURCE-PINS.json and source/EXTERNAL.json. diff --git a/research/clifford-quadratic-orbit-blocks/PROOF.md b/research/clifford-quadratic-orbit-blocks/PROOF.md new file mode 100644 index 0000000000..ffc18b1650 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/PROOF.md @@ -0,0 +1,338 @@ +# Two actual quadratic-orbit blocks of the width-ten Clifford Gram matrix + +## 1. Statement and exact source group + +Use the group of PR6714: $G$ consists of the unitary three-qubit Clifford +matrices with entries in $D=\mathbb Z[i,1/2]$. Its natural representation +$V$ has dimension eight. Write $z=iI$, let $P$ be the Pauli subgroup, and +put $S=G/P=\operatorname{Sp}(6,2)$. The scalar subgroup is $\mu_4$. +No ordinary Hadamard with an unavailable scalar phase, eighth root of +unity, or enlarged Clifford group is substituted for this source group. + +The retained source proofs are +[PR6714 at f7f32a18](https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md) +and +[PR6794 at c6252da0](https://github.com/petalas/integer-mult-bounds/blob/c6252da020819a08ef2b2ff14280146c43ad374c/research/clifford-transvection-conditioning/PROOF.md). +The package source pins bind their exact bytes and the retained table +and width-nine inputs. + +Subject to the retained PR6714 quotient-table identification, width-nine +decomposition, and normalized Gram-block formula, the following are two +actual irreducibles and their width-ten data: + +| Irreducible $\mu$ | Dimension | Multiplicity in $V^{\otimes10}$ | Gram eigenvalue at width ten | Regular block dimension | +| --- | --- | --- | --- | --- | +| $\operatorname{Sym}^2V$ | 36 | 2244 | $176715/32768$ | 1296 | +| $\Lambda^2V$ | 28 | 2159 | $874395/131072$ | 784 | + +These are actual block eigenvalues, not the endpoints of a trace +relaxation. They are not claimed to be the smallest or largest eigenvalue +of the entire Gram matrix. The final column is the dimension of each +specified regular block; if another irreducible has the same eigenvalue, +the global spectral multiplicity is larger. + +PR6794 asks for actual quadratic-form stabilizer decompositions as a +first step toward actual spectral endpoints. This note resolves just the +two multiplicity-one Pauli-orbit modules below. It does not determine +all even-sector irreducibles or their decompositions. + +## 2. Bell matrices give the two irreducible modules + +Let $F=\mathbb F_2^3\oplus\mathbb F_2^3$, write $v=(a,b)$, and define + +\[ + q_0(v)=a\cdot b,\qquad + \omega((a,b),(c,d))=a\cdot d+b\cdot c. +\] + +The dots in these expressions are binary. Use the source's Hermitian +Pauli representatives + +\[ + W_v=i^{\,q_0(v)}X^aZ^b. +\] + +They are Hermitian unitary matrices, satisfy $W_v^2=I$, and obey + +\[ + W_v^T=(-1)^{q_0(v)}W_v,\qquad + W_vW_w=(-1)^{\omega(v,w)}W_wW_v. \tag{1} +\] + +With the source binary-dot convention a tensor product of single-qubit +$Y$ matrices may differ from $W_v$ by a real sign. This causes no change +in (1) or the argument. We keep the source representatives throughout. + +Identify $V\otimes V$ with $8$-by-$8$ matrices by +$e_j\otimes e_k\mapsto E_{jk}$. Its actual $G$ action is congruence + +\[ + B\longmapsto gBg^T. \tag{2} +\] + +The 64 matrices $B_w=W_w$ form a basis, for example by Pauli trace +orthogonality. From (1) their symmetric and skew-symmetric spans have +dimensions 36 and 28, respectively, and are precisely +$\operatorname{Sym}^2 V$ and $\Lambda^2V$ under this identification. +For the count, $a=0$ allows eight $b$ with $a\cdot b=0$; each of the +other seven $a$ allows four of each parity. Thus the two counts are +$8+7\cdot4=36$ and $7\cdot4=28$. + +Under a Pauli representative, (2) acts on a basis line by + +\[ + W_vB_wW_v^T + =(-1)^{q_0(v)+\omega(v,w)}B_w. +\] + +Set $Q_w(v)=q_0(v)+\omega(v,w)$. The central generator $z$ acts by +$i^2=-1$ in (2), so these are the source's one-dimensional Pauli +characters with central value $-1$. The $Q_w$ are all distinct. If +$w=(c,d)$, their linear parameters are $\alpha=d,\ \beta=c$, and + +\[ + \operatorname{Arf}(Q_w)=c\cdot d=q_0(w). + \tag{3} +\] + +The source quotient $S$ acts transitively on each of the two Arf orbits +of quadratic forms. Pauli conjugation signs are invisible in these +characters because $-I=z^2$ acts as one. Consequently (2) permutes the +36, respectively 28, one-dimensional weight spaces transitively. + +This proves irreducibility of each actual $G$ module. Indeed, any +nonzero invariant subspace splits into its Pauli character components +over $\mathbb C$, by the character projectors for this finite abelian +quotient of $P$. Since every weight space is one-dimensional, it contains +a whole such line. Transitivity under $G$ then gives every line in the +orbit. Denote these irreducibles by $\mu_{36}$ and $\mu_{28}$. +Their central value is $\mu_N(z)=-I$. + +## 3. A phase-exact all-element intertwiner + +Let $\mathcal O_N$ be the corresponding set of quadratic forms, and +let $\Pi_N=\mathbb C[\mathcal O_N]$ be its ordinary permutation +representation, inflated from $S$. For any actual $g\in G$, the +one-dimensional weight-space argument gives + +\[ + gB_Qg^T=\theta_Q(g)B_{Q'},\qquad + |\theta_Q(g)|=1, \tag{4} +\] + +where $Q'$ is the permuted label. The modulus follows also by preserving +the Hilbert-Schmidt norm. There is no assumption that $\theta_Q$ is one, +or that (2) itself is the unphased permutation representation. + +Define a linear map + +\[ + \Phi:V\otimes\Pi_N\longrightarrow\overline V\otimes\mu_N, + \qquad + \Phi(v\otimes e_Q)=B_Q^\dagger v\otimes B_Q. \tag{5} +\] + +Each $B_Q$ is invertible, so (5) is an isomorphism: on each labelled +summand it is simply the invertible map $B_Q^\dagger$ on an +eight-dimensional vector. + +Taking the adjoint of (4), and using unitarity of $g$, gives + +\[ + \overline g\,B_Q^\dagger g^\dagger + =\overline{\theta_Q(g)}B_{Q'}^\dagger,\qquad + \theta_Q(g)\,\overline g\,B_Q^\dagger + =B_{Q'}^\dagger g. \tag{6} +\] + +Thus the action on the right of (5) is + +\[ + (\overline g\otimes\mu_N(g))\Phi(v\otimes e_Q) + =\theta_Q(g)\overline gB_Q^\dagger v\otimes B_{Q'} + =\Phi(gv\otimes e_{Q'}). +\] + +It follows that the honest $G$ representations satisfy + +\[ + \overline V\otimes\mu_N + \cong V\otimes\Pi_N. \tag{7} +\] + +This is an all-element intertwiner, including every Pauli element and +every scalar in $\mu_4$. In particular it is not a character-division +argument at elements with nonzero natural trace, nor an equality only +up to a central phase. The conjugate natural representation in (5)--(7) +is essential. + +## 4. The two permutation modules are rank two + +For completeness, the quadratic-form permutation action is two-transitive. +Fix a form $Q$. Every other form with the same polar form is uniquely +$Q+\omega(-,w)$. The standard Arf identity is + +\[ + \operatorname{Arf}(Q+\omega(-,w)) + =\operatorname{Arf}(Q)+Q(w). \tag{8} +\] + +In the present coordinates this follows by writing +$Q(a,b)=a\cdot b+\alpha\cdot a+\beta\cdot b$ and +$w=(c,d)$: the new linear parameters are $\alpha+d,\beta+c$; +the difference of the two Arf values is +$\alpha\cdot c+\beta\cdot d+c\cdot d=Q(w)$. +Thus the other forms in the same orbit are parameterized by the +nonzero singular vectors $w$, those with $Q(w)=0$. + +Here is an elementary proof that $O(Q)$ is transitive on those vectors. +For any $a$ with $Q(a)=1$, the symplectic transvection +$\tau_a(x)=x+\omega(x,a)a$ preserves $Q$. +If distinct nonzero singular $u,v$ satisfy $\omega(u,v)=1$, +then $Q(u+v)=1$ and $\tau_{u+v}$ sends $u$ to $v$. +If instead $\omega(u,v)=0$, the two independent linear conditions +$\omega(u,c)=\omega(v,c)=1$ have a solution, by nondegeneracy of +$\omega$. Replacing $c$ by $c+u$ preserves both conditions and toggles +$Q(c)$, so choose $c$ singular. The transvections with directions +$u+c$ and $v+c$ preserve $Q$ and send $u$ first to $c$, then to $v$. +This proves the desired transitivity without a finite orbit enumeration. + +The point stabilizer in $S$ is $O(Q)$, so it is transitive on all other +points of the quadratic-form orbit. Hence $\Pi_N$ is two-transitive. +Over $\mathbb C$ its commuting algebra has dimension two, since its +matrix entries are constant on the two orbits of ordered point pairs. +The constants are a single trivial constituent. Semisimplicity then +implies that the augmentation summand is one irreducible, of dimension +$N-1$. Therefore + +\[ + \Pi_{36}=1\oplus\sigma_{35},\qquad + \Pi_{28}=1\oplus\sigma_{27}. \tag{9} +\] + +These steps are classical permutation-representation and orthogonal-space +arguments; no new general representation-theoretic principle is claimed. + +## 5. Bind the quotient constituents to the retained source rows + +The following values are read from the source's complete thirty-row +quotient identification and its width-nine multiplicities. Row numbers +are the published table's original row indices. + +| Published row | Degree | Transvection character | Width-nine multiplicity | +| --- | --- | --- | --- | +| 1 | 1 | 1 | 269 | +| 6 | 27 | 15 | 1890 | +| 7 | 35 | 15 | 1975 | +| 8 | 35 | -5 | 175 | + +There is just one degree-27 irreducible among those quotient rows, so +the constituent $\sigma_{27}$ in (9) is row 6. There are two degree-35 +possibilities, rows 7 and 8; the dimension alone does not distinguish them. + +A transvection fixes sixteen forms in each Arf orbit, as in PR6714. +One can see the count by taking its direction to be the first +coordinate vector: the fixed-form condition is $\alpha_1=1$, and each +choice of the other four parameters determines $\beta_1$ uniquely for +either chosen Arf value. Thus +$\chi_{\Pi_N}(t)=16$ and the augmentation character is 15. +This selects row 7, not row 8, for $\sigma_{35}$. + +Combining (7) and (9) therefore gives the actual decompositions + +\[ + \begin{split} + \overline V\otimes\mu_{36} + &\cong (V\otimes1)\oplus(V\otimes\sigma_{\mathrm{row}\,7}),\\ + \overline V\otimes\mu_{28} + &\cong (V\otimes1)\oplus(V\otimes\sigma_{\mathrm{row}\,6}). + \end{split} \tag{10} +\] + +The source proves that the $V\otimes\sigma$ are the distinct irreducibles +in the relevant odd central sector. Their honest quotient identification +and numerical multiplicities are inherited data, not reconstructed by +this argument. The Bell construction and (7) determine which of those +source rows actually occur here. + +## 6. Width-ten multiplicities and regular-block eigenvalues + +For any irreducible $\mu$ in this central sector, tensor reciprocity gives + +\[ + \dim\operatorname{Hom}_G(\mu,V^{\otimes10}) + =\dim\operatorname{Hom}_G(\overline V\otimes\mu,V^{\otimes9}). + \tag{11} +\] + +Using (10), the retained width-nine decomposition and the two rows in +each direct sum show + +\[ + m_{\mu_{36}}(10)=269+1975=2244,\qquad + m_{\mu_{28}}(10)=269+1890=2159. \tag{12} +\] + +There is no extra degree factor in (12): each summand in (10) occurs +once, and (11) is a dimension of a Hom space between irreducibles. +Both $\mu_N$ have central value $-1$, which is the width-ten sector. + +Let $M=|G/\langle z\rangle|=92897280$ and let $H_{10}$ be the source +normalized character-power Gram matrix. Its inherited block formula is + +\[ + \lambda_\mu(10)=\frac{M}{8^{10}} + \frac{m_\mu(10)}{\dim\mu}, + \qquad \frac{M}{8^{10}}=\frac{2835}{32768}. +\] + +Substituting (12) gives + +\[ + \lambda_{\mu_{36}}(10) + =\frac{2835}{32768}\frac{2244}{36} + =\frac{176715}{32768},\qquad + \lambda_{\mu_{28}}(10) + =\frac{2835}{32768}\frac{2159}{28} + =\frac{874395}{131072}. \tag{13} +\] + +The central-character regular ideal has a matrix block of dimension +$(\dim\mu)^2$ for each irreducible. Thus the two contributions have +dimensions $36^2=1296$ and $28^2=784$. These do not have an additional +factor four from the scalar lifts. Other blocks can share an eigenvalue; +(13) does not assert its total multiplicity in the whole Gram matrix. +The formulas are at width ten, not unchanged eigenvalue formulas for +every larger tensor width. + +## 7. Evidence, credits, and remaining obligations + +This is a source-aware written calculation. The coordinator supplied +the proposed Bell/intertwiner recipe before this draft, and this author +had prior source exposure to PR6714, PR6794, PR6718 and the later +order-three conditioning work. The recipe was critically checked rather +than treated as accepted. It is not blind discovery, independent human +review, or formal-kernel acceptance. This proof role executed no source +or new scientific program, table reconstruction, orbit enumeration, +constructor, tensor calculation, LP, or eigenvalue experiment. + +Alephnan6714 supplies the actual Gaussian-dyadic group, its full +symplectic quotient, the quadratic-form orbit framework, width-nine +decomposition and normalized Gram-block formula. The table identification +uses the published work of Chin-Yen Lee, Wei-Hsuan Yu, Yung-Ning Peng +and Ching-Jui Lai. Nick Petalas6794 supplies the conditioning context +and the explicit actual-stabilizer-decomposition handoff. +The source-aware PR6718 proof review and the later conditioning result +are predecessor context, not fresh evidence or a decomposition replay. +Bell/Pauli identifications, multiplicity-free weight-space arguments, +tensor reciprocity, rank-two permutation modules and (8) are classical. +The contribution is their explicit phase-correct application to these +two source-bound actual blocks. + +The source group/table identification, all other irreducible +decompositions, and all uncomputed spectral blocks remain distinct. +Nothing here proves global spectral endpoints, an exact condition +number, a new tensor threshold, or a selected-frontier improvement. +Native realization, a complete physical caller and its invoice, +precision/overflow, the supplier hypotheses and all five selected +framework assumptions remain outside this calculation. diff --git a/research/clifford-quadratic-orbit-blocks/README.md b/research/clifford-quadratic-orbit-blocks/README.md new file mode 100644 index 0000000000..39c3b7afba --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/README.md @@ -0,0 +1,45 @@ +# Two actual even-sector blocks for the Gaussian-dyadic three-qubit group + +Under the retained group/table/width-nine/Gram premises, this source-bound calculation proves two actual even-sector irreducible blocks at tensor width ten. It answers a bounded part of Nick Petalas [PR6794](https://github.com/CrocSwap/integer-mult-bounds/pull/6794)'s actual stabilizer/decomposition question. + +| Actual irreducible | Dimension | Width-ten multiplicity | Gram eigenvalue | Regular block dimension | +| --- | --- | --- | --- | --- | +| Sym²V | 36 | 2244 | 176715/32768 | 1296 | +| Λ²V | 28 | 2159 | 874395/131072 | 784 | + +The last column is a contribution from the specified regular block, not the total multiplicity of an eigenvalue if other irreducibles coincide with it. These are actual blocks, not claimed global spectral endpoints. + +The group is precisely the unitary three-qubit Clifford group over D=Z[i,1/2], with scalar kernel mu4 and z=iI, as in alephnan6714. Ordinary Hadamard and scalar omega/mu8 conventions would change this group. Legal generators S, Rx=((1+i)I+(1-i)X)/2, CNOT, Paulis and central iI stay within the source group. + +## Mathematical scope + +Use Hermitian Pauli matrices as Bell-matrix bases. Transpose parity separates Sym²V (36 dimensions) and Λ²V (28). Their distinct one-dimensional Pauli weight spaces are the two quadratic-form orbits; transitivity makes each module irreducible. The explicit map v tensor e_Q -> B_Q dagger v tensor B_Q identifies Vbar tensor µ with V tensor the ordinary permutation module on its quadratic orbit, with the actual phases cancelled. [PROOF.md](PROOF.md) supplies the quantified argument and source bindings; the finite checker is corroboration. + +Two-transitivity gives permutation modules1+35 and1+27. The two degree35 table rows must be distinguished by transvection trace15 versus−5. The source width-nine multiplicities, rather than a rebuilt table or historical engine, then determine the two width-ten block values. The credited width-nine multiplicities give269+1975=2244 and269+1890=2159; the source Gram formula gives the table above. The written all-element argument and finite evidence remain distinct. + +No full even-sector classification, actual spectral endpoints, sharp condition number, threshold improvement or total eigenvalue multiplicity is claimed. A regular matrix block's dimension is d²; other irreducibles may share its eigenvalue. Own completed6822's order-three/LP/traces are excluded and are not replayed. + +## Evidence and reproduction + +The first root-controlled diagnostic passed under CPython3.12.14 in0.3259265seconds at23.84375MiB maximum RSS, empty stderr and all14 then-present hashes unchanged. The new standard-library checker authenticates five retained source objects (75,775bytes) before any matrix calculation. It imports/runs no source scientific engine, full group census, full character-table calculation, native/Lean/Docker build, selected cold replay or old6822 order-three/LP work. + +Observed domains:19 actual Gaussian-dyadic generators;1,216 signed Pauli conjugations,1,216 Bell congruences and1,216 complete8x8 intertwiner identities;4,096 Bell inner products and4,096 literal Pauli weight lines;77,824 distinct quadratic transport cases (two quadratic evaluations each), with77,824 linearity and77,824 symplectic-pairing comparisons;38 square-character checks. Ordered-pair BFS reaches1,260 and756 distinct pairs and checks38,304 directed generator edges. Four witnessed mathematical controls distinguish wrong dual, conjugation, degree35 row and transpose/Arf assignment; a separate multiple-Y basis-gauge guard does not call the alternate phase an illegal group element. Three strict parser controls also pass. + +The Pauli matrices, quadratic forms and classical elementary quantities already appear in the source lineage. They are not new objects or a rediscovered construction. The new binding is the phase-correct intertwiner and these actual source-bound modules/multiplicities. The full21,547-byte packet is retained (SHA256 dfa9b37816dc1f9d8fe7393aa246374e4b751b26dddd6e309d9fad48b537feb1); subsequent direct/registered/export/hosted observations are separate delivery receipts. Finite generator/orbit checks corroborate the all-element written proof and inherited numerical premises; they are not human or proof-kernel acceptance. + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-quadratic-orbit-blocks +python3.12 -B scripts/check_research_commit.py --package research/clifford-quadratic-orbit-blocks --check-source-history --check-modes +``` + +SOURCES contains canonical selection/catalogue/legal provenance. SOURCE-PINS separately binds the five local inert mathematical source files to exact foreign head/path/blob/mode/size/SHA; their association was checked against resident source trees, with fresh matching bytes and current heads. These foreign commits are not publication ancestry. VERIFY.inputs=[] reflects the package-local runtime closure. Default normal/O commands compare the whole typed retained RESULT; --emit is generation stdout only, with no self-hash cycle or runtime Git/network. + +## Open next questions + +Determine an actually uncovered remaining quadratic-stabilizer representation and exact extension before claiming the full width-ten spectral endpoints. The other even irreducibles and possible eigenvalue coincidences remain unresolved here; no follow-on work is reserved. For physical use, bind one actual native caller and complete preparation/routing/chronology/precision/recovery/ownership/restoration/stock/recursive invoice. These costs are unknown. All five selected assumptions, selected kappa and frontier remain unchanged; the original native/formal task gate remains unmet. + +## Credit and exposure + +Credit Petalas6794 for the prior807 relaxation and actual-spectrum request; alephnan6714 for the group, source multiplicities, Pauli orbit, reciprocity and Gram framework; Lee-Yu-Peng-Lai for the published character table; Ali Romman/MatShep and retained Clifford/stabilizer lineage. Classical Bell/Pauli/symmetric/exterior/permutation/transvection/character methods retain priority. [LICENSE](LICENSE), [NOTICE](NOTICE) and exact source provenance remain. + +The root proposed the unaccepted intertwiner/multiplicity recipe during prior orientation, including an ordinary-H/omega convention which source reading rejected before any new mathematical execution. Source-aware AI proposal/proof/implementation/overlap/metadata roles see those sources and the recipe. Substantial OpenAI Codex assistance is disclosed; this is not blind independent, human or proof-kernel acceptance. The inherited group/table/width-nine framework remains a source premise, not a newly replayed theorem. diff --git a/research/clifford-quadratic-orbit-blocks/RESULT.json b/research/clifford-quadratic-orbit-blocks/RESULT.json new file mode 100644 index 0000000000..ad619b797b --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/RESULT.json @@ -0,0 +1,5657 @@ +{ + "actual_width10_blocks": [ + { + "Gram_eigenvalue": [ + 176715, + 32768 + ], + "actual_even_dimension": 36, + "inherited_m9_constituent": 1975, + "inherited_m9_trivial": 269, + "m_mu_at_width10": 2244, + "published_constituent_row": 7, + "quotient_constituent_degree": 35, + "regular_matrix_block_dimension": 1296, + "transvection_character": 15 + }, + { + "Gram_eigenvalue": [ + 874395, + 131072 + ], + "actual_even_dimension": 28, + "inherited_m9_constituent": 1890, + "inherited_m9_trivial": 269, + "m_mu_at_width10": 2159, + "published_constituent_row": 6, + "quotient_constituent_degree": 27, + "regular_matrix_block_dimension": 784, + "transvection_character": 15 + } + ], + "basis_checks": { + "distinct_Bell_inner_products": 4096, + "distinct_form_vector_pairs": 4096, + "literal_weight_line_cases": 4096, + "orthogonality_sha256": "69bbf33c7d4f1f4654941d16a9982b3ea9e2f8e0b614b93459fed79c34b95059", + "weight_line_sha256": "95c215bf3a48cedff1999af3266538a35a4815240b99b66ecc707f059b1a5333" + }, + "conventions": { + "Bell_phase": "i^parity(a&b)", + "Q_w": "parity(a_v&b_v)+omega(v,w) mod2", + "base_ring": "Z[i,1/2]", + "center_order": 4, + "generator_alphabet": "Xj,Zj,Sj,Rxj; six directed CNOT; central iI", + "intertwiner": "theta*bar(g_num)*B_w^dagger=B_target^dagger*g_num", + "label": "a+8*b", + "natural_dimension": 8 + }, + "generator_action_counts": { + "Bell_congruences": 1216, + "distinct_square_character_checks": 38, + "generators": 19, + "intertwiner_sha256": "2054cdc34b35434971cb1c40db0ff9a9265aaae81bcb99a049db3a264cfc9e15", + "quadratic_transport_cases": 77824, + "signed_Pauli_conjugations": 1216, + "symplectic_linearity_pairs": 77824, + "symplectic_pairing_pairs": 77824, + "whole_matrix_intertwiners": 1216 + }, + "generators": [ + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 4, + 0 + ], + [ + -4, + 0 + ] + ], + "denominator": 1, + "name": "X0", + "numerator_sha256": "c027ee0f003fa020d04fcda3a7d5bdf1968a58ca9167cd0b4066c9e0781c1e15" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 0, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 4, + 0 + ], + [ + -4, + 0 + ] + ], + "denominator": 1, + "name": "Z0", + "numerator_sha256": "b488ddbd6aca0fe2f2dc1dc5bb6d012f1a94710a874fe41803464fbe9c8e8df8" + }, + { + "Bell_labels": [ + 8, + 1, + 10, + 3, + 12, + 5, + 14, + 7, + 0, + 9, + 2, + 11, + 4, + 13, + 6, + 15, + 24, + 17, + 26, + 19, + 28, + 21, + 30, + 23, + 16, + 25, + 18, + 27, + 20, + 29, + 22, + 31, + 40, + 33, + 42, + 35, + 44, + 37, + 46, + 39, + 32, + 41, + 34, + 43, + 36, + 45, + 38, + 47, + 56, + 49, + 58, + 51, + 60, + 53, + 62, + 55, + 48, + 57, + 50, + 59, + 52, + 61, + 54, + 63 + ], + "Bell_phase_exponents": [ + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 1 + ], + "Pauli_labels": [ + 0, + 9, + 2, + 11, + 4, + 13, + 6, + 15, + 8, + 1, + 10, + 3, + 12, + 5, + 14, + 7, + 16, + 25, + 18, + 27, + 20, + 29, + 22, + 31, + 24, + 17, + 26, + 19, + 28, + 21, + 30, + 23, + 32, + 41, + 34, + 43, + 36, + 45, + 38, + 47, + 40, + 33, + 42, + 35, + 44, + 37, + 46, + 39, + 48, + 57, + 50, + 59, + 52, + 61, + 54, + 63, + 56, + 49, + 58, + 51, + 60, + 53, + 62, + 55 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "denominator": 1, + "name": "S0", + "numerator_sha256": "e8c371bc5047eb64cf2726631cbaaa2795f62d3c7ed43d9bd28757010d49e427" + }, + { + "Bell_labels": [ + 1, + 0, + 3, + 2, + 5, + 4, + 7, + 6, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 16, + 19, + 18, + 21, + 20, + 23, + 22, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 33, + 32, + 35, + 34, + 37, + 36, + 39, + 38, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 49, + 48, + 51, + 50, + 53, + 52, + 55, + 54, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 9, + 8, + 11, + 10, + 13, + 12, + 15, + 14, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 25, + 24, + 27, + 26, + 29, + 28, + 31, + 30, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 41, + 40, + 43, + 42, + 45, + 44, + 47, + 46, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 57, + 56, + 59, + 58, + 61, + 60, + 63, + 62 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + 1, + -1, + 1, + -1, + -1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "denominator": 2, + "name": "Rx0", + "numerator_sha256": "0084ee27a7babb80b97c9941160fe86a36304d6a518bb576a29e6b6a4d0dac79" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 4, + 0 + ], + [ + -4, + 0 + ] + ], + "denominator": 1, + "name": "X1", + "numerator_sha256": "447504c6853b4ce925bb4d67f8643bc0ce8d9b167eabf62977b565add49d154b" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2, + 0, + 0, + 2, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 4, + 0 + ], + [ + -4, + 0 + ] + ], + "denominator": 1, + "name": "Z1", + "numerator_sha256": "0932ed8dbcff1e812272d07c3e756c01a56e57343b22edec5da4a91ee86bfa0e" + }, + { + "Bell_labels": [ + 16, + 17, + 2, + 3, + 20, + 21, + 6, + 7, + 24, + 25, + 10, + 11, + 28, + 29, + 14, + 15, + 0, + 1, + 18, + 19, + 4, + 5, + 22, + 23, + 8, + 9, + 26, + 27, + 12, + 13, + 30, + 31, + 48, + 49, + 34, + 35, + 52, + 53, + 38, + 39, + 56, + 57, + 42, + 43, + 60, + 61, + 46, + 47, + 32, + 33, + 50, + 51, + 36, + 37, + 54, + 55, + 40, + 41, + 58, + 59, + 44, + 45, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1 + ], + "Pauli_labels": [ + 0, + 1, + 18, + 19, + 4, + 5, + 22, + 23, + 8, + 9, + 26, + 27, + 12, + 13, + 30, + 31, + 16, + 17, + 2, + 3, + 20, + 21, + 6, + 7, + 24, + 25, + 10, + 11, + 28, + 29, + 14, + 15, + 32, + 33, + 50, + 51, + 36, + 37, + 54, + 55, + 40, + 41, + 58, + 59, + 44, + 45, + 62, + 63, + 48, + 49, + 34, + 35, + 52, + 53, + 38, + 39, + 56, + 57, + 42, + 43, + 60, + 61, + 46, + 47 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + -1, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "denominator": 1, + "name": "S1", + "numerator_sha256": "5dd76b3c756cd104620d044fbe6f83887333e5097f69909f474e608eedae253d" + }, + { + "Bell_labels": [ + 2, + 3, + 0, + 1, + 6, + 7, + 4, + 5, + 10, + 11, + 8, + 9, + 14, + 15, + 12, + 13, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 34, + 35, + 32, + 33, + 38, + 39, + 36, + 37, + 42, + 43, + 40, + 41, + 46, + 47, + 44, + 45, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 18, + 19, + 16, + 17, + 22, + 23, + 20, + 21, + 26, + 27, + 24, + 25, + 30, + 31, + 28, + 29, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 50, + 51, + 48, + 49, + 54, + 55, + 52, + 53, + 58, + 59, + 56, + 57, + 62, + 63, + 60, + 61 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + 1, + 1, + -1, + 1, + -1, + -1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "denominator": 2, + "name": "Rx1", + "numerator_sha256": "b7375bee46138ed41d2a70233282040d7080084712daa30295355907d79d6d95" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 4, + 0 + ], + [ + -4, + 0 + ] + ], + "denominator": 1, + "name": "X2", + "numerator_sha256": "ff098bc53b07a5e9030bfbd80db7ffd48518cef75348bec2c6a5300bbd913b34" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 4, + 0 + ], + [ + -4, + 0 + ] + ], + "denominator": 1, + "name": "Z2", + "numerator_sha256": "bfda592a66e71637d1ac208704cea910292401f10f2e3ac94e3516137ac9de54" + }, + { + "Bell_labels": [ + 32, + 33, + 34, + 35, + 4, + 5, + 6, + 7, + 40, + 41, + 42, + 43, + 12, + 13, + 14, + 15, + 48, + 49, + 50, + 51, + 20, + 21, + 22, + 23, + 56, + 57, + 58, + 59, + 28, + 29, + 30, + 31, + 0, + 1, + 2, + 3, + 36, + 37, + 38, + 39, + 8, + 9, + 10, + 11, + 44, + 45, + 46, + 47, + 16, + 17, + 18, + 19, + 52, + 53, + 54, + 55, + 24, + 25, + 26, + 27, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 36, + 37, + 38, + 39, + 8, + 9, + 10, + 11, + 44, + 45, + 46, + 47, + 16, + 17, + 18, + 19, + 52, + 53, + 54, + 55, + 24, + 25, + 26, + 27, + 60, + 61, + 62, + 63, + 32, + 33, + 34, + 35, + 4, + 5, + 6, + 7, + 40, + 41, + 42, + 43, + 12, + 13, + 14, + 15, + 48, + 49, + 50, + 51, + 20, + 21, + 22, + 23, + 56, + 57, + 58, + 59, + 28, + 29, + 30, + 31 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + 1, + 1, + -1 + ], + "Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "denominator": 1, + "name": "S2", + "numerator_sha256": "214632987a5c890ee9061788849900b52c254240490a8bda5f01a37d2846d89f" + }, + { + "Bell_labels": [ + 4, + 5, + 6, + 7, + 0, + 1, + 2, + 3, + 12, + 13, + 14, + 15, + 8, + 9, + 10, + 11, + 20, + 21, + 22, + 23, + 16, + 17, + 18, + 19, + 28, + 29, + 30, + 31, + 24, + 25, + 26, + 27, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 36, + 37, + 38, + 39, + 32, + 33, + 34, + 35, + 44, + 45, + 46, + 47, + 40, + 41, + 42, + 43, + 52, + 53, + 54, + 55, + 48, + 49, + 50, + 51, + 60, + 61, + 62, + 63, + 56, + 57, + 58, + 59 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + 1, + -1, + 1, + 1, + -1, + 1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + 1, + 1, + -1, + 1, + -1, + -1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "denominator": 2, + "name": "Rx2", + "numerator_sha256": "5a889be687bbcd1da242b3424ec7639226af854846fc864a90da4b8f4a6b5d14" + }, + { + "Bell_labels": [ + 0, + 3, + 2, + 1, + 4, + 7, + 6, + 5, + 8, + 11, + 10, + 9, + 12, + 15, + 14, + 13, + 24, + 27, + 26, + 25, + 28, + 31, + 30, + 29, + 16, + 19, + 18, + 17, + 20, + 23, + 22, + 21, + 32, + 35, + 34, + 33, + 36, + 39, + 38, + 37, + 40, + 43, + 42, + 41, + 44, + 47, + 46, + 45, + 56, + 59, + 58, + 57, + 60, + 63, + 62, + 61, + 48, + 51, + 50, + 49, + 52, + 55, + 54, + 53 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Pauli_labels": [ + 0, + 3, + 2, + 1, + 4, + 7, + 6, + 5, + 8, + 11, + 10, + 9, + 12, + 15, + 14, + 13, + 24, + 27, + 26, + 25, + 28, + 31, + 30, + 29, + 16, + 19, + 18, + 17, + 20, + 23, + 22, + 21, + 32, + 35, + 34, + 33, + 36, + 39, + 38, + 37, + 40, + 43, + 42, + 41, + 44, + 47, + 46, + 45, + 56, + 59, + 58, + 57, + 60, + 63, + 62, + 61, + 48, + 51, + 50, + 49, + 52, + 55, + 54, + 53 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 12, + 0 + ], + [ + 4, + 0 + ] + ], + "denominator": 1, + "name": "CNOT01", + "numerator_sha256": "b74bb7bde6bae5d4cf98624c097fb7e736d1c290656988c40c617253f396a40b" + }, + { + "Bell_labels": [ + 0, + 5, + 2, + 7, + 4, + 1, + 6, + 3, + 8, + 13, + 10, + 15, + 12, + 9, + 14, + 11, + 16, + 21, + 18, + 23, + 20, + 17, + 22, + 19, + 24, + 29, + 26, + 31, + 28, + 25, + 30, + 27, + 40, + 45, + 42, + 47, + 44, + 41, + 46, + 43, + 32, + 37, + 34, + 39, + 36, + 33, + 38, + 35, + 56, + 61, + 58, + 63, + 60, + 57, + 62, + 59, + 48, + 53, + 50, + 55, + 52, + 49, + 54, + 51 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Pauli_labels": [ + 0, + 5, + 2, + 7, + 4, + 1, + 6, + 3, + 8, + 13, + 10, + 15, + 12, + 9, + 14, + 11, + 16, + 21, + 18, + 23, + 20, + 17, + 22, + 19, + 24, + 29, + 26, + 31, + 28, + 25, + 30, + 27, + 40, + 45, + 42, + 47, + 44, + 41, + 46, + 43, + 32, + 37, + 34, + 39, + 36, + 33, + 38, + 35, + 56, + 61, + 58, + 63, + 60, + 57, + 62, + 59, + 48, + 53, + 50, + 55, + 52, + 49, + 54, + 51 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 12, + 0 + ], + [ + 4, + 0 + ] + ], + "denominator": 1, + "name": "CNOT02", + "numerator_sha256": "f10e4baa8b35d3be639ddf99eddc38dc8c96ac1177ea265a278a8afc01d6910b" + }, + { + "Bell_labels": [ + 0, + 1, + 3, + 2, + 4, + 5, + 7, + 6, + 24, + 25, + 27, + 26, + 28, + 29, + 31, + 30, + 16, + 17, + 19, + 18, + 20, + 21, + 23, + 22, + 8, + 9, + 11, + 10, + 12, + 13, + 15, + 14, + 32, + 33, + 35, + 34, + 36, + 37, + 39, + 38, + 56, + 57, + 59, + 58, + 60, + 61, + 63, + 62, + 48, + 49, + 51, + 50, + 52, + 53, + 55, + 54, + 40, + 41, + 43, + 42, + 44, + 45, + 47, + 46 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Pauli_labels": [ + 0, + 1, + 3, + 2, + 4, + 5, + 7, + 6, + 24, + 25, + 27, + 26, + 28, + 29, + 31, + 30, + 16, + 17, + 19, + 18, + 20, + 21, + 23, + 22, + 8, + 9, + 11, + 10, + 12, + 13, + 15, + 14, + 32, + 33, + 35, + 34, + 36, + 37, + 39, + 38, + 56, + 57, + 59, + 58, + 60, + 61, + 63, + 62, + 48, + 49, + 51, + 50, + 52, + 53, + 55, + 54, + 40, + 41, + 43, + 42, + 44, + 45, + 47, + 46 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 12, + 0 + ], + [ + 4, + 0 + ] + ], + "denominator": 1, + "name": "CNOT10", + "numerator_sha256": "2e44d1b50803d245314155c4b47dfb341bcf68ef6dcc27500d24f534841d5fe6" + }, + { + "Bell_labels": [ + 0, + 1, + 6, + 7, + 4, + 5, + 2, + 3, + 8, + 9, + 14, + 15, + 12, + 13, + 10, + 11, + 16, + 17, + 22, + 23, + 20, + 21, + 18, + 19, + 24, + 25, + 30, + 31, + 28, + 29, + 26, + 27, + 48, + 49, + 54, + 55, + 52, + 53, + 50, + 51, + 56, + 57, + 62, + 63, + 60, + 61, + 58, + 59, + 32, + 33, + 38, + 39, + 36, + 37, + 34, + 35, + 40, + 41, + 46, + 47, + 44, + 45, + 42, + 43 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Pauli_labels": [ + 0, + 1, + 6, + 7, + 4, + 5, + 2, + 3, + 8, + 9, + 14, + 15, + 12, + 13, + 10, + 11, + 16, + 17, + 22, + 23, + 20, + 21, + 18, + 19, + 24, + 25, + 30, + 31, + 28, + 29, + 26, + 27, + 48, + 49, + 54, + 55, + 52, + 53, + 50, + 51, + 56, + 57, + 62, + 63, + 60, + 61, + 58, + 59, + 32, + 33, + 38, + 39, + 36, + 37, + 34, + 35, + 40, + 41, + 46, + 47, + 44, + 45, + 42, + 43 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 12, + 0 + ], + [ + 4, + 0 + ] + ], + "denominator": 1, + "name": "CNOT12", + "numerator_sha256": "0af03afd7f71589b412837d18640f789c03f9768f565323cb4299e9cc410a5a6" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 5, + 4, + 7, + 6, + 40, + 41, + 42, + 43, + 45, + 44, + 47, + 46, + 16, + 17, + 18, + 19, + 21, + 20, + 23, + 22, + 56, + 57, + 58, + 59, + 61, + 60, + 63, + 62, + 32, + 33, + 34, + 35, + 37, + 36, + 39, + 38, + 8, + 9, + 10, + 11, + 13, + 12, + 15, + 14, + 48, + 49, + 50, + 51, + 53, + 52, + 55, + 54, + 24, + 25, + 26, + 27, + 29, + 28, + 31, + 30 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 5, + 4, + 7, + 6, + 40, + 41, + 42, + 43, + 45, + 44, + 47, + 46, + 16, + 17, + 18, + 19, + 21, + 20, + 23, + 22, + 56, + 57, + 58, + 59, + 61, + 60, + 63, + 62, + 32, + 33, + 34, + 35, + 37, + 36, + 39, + 38, + 8, + 9, + 10, + 11, + 13, + 12, + 15, + 14, + 48, + 49, + 50, + 51, + 53, + 52, + 55, + 54, + 24, + 25, + 26, + 27, + 29, + 28, + 31, + 30 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 12, + 0 + ], + [ + 4, + 0 + ] + ], + "denominator": 1, + "name": "CNOT20", + "numerator_sha256": "542e1d4de8119122f2e6c61a684e994f0269efabb06f233026ffc27f800a8235" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 6, + 7, + 4, + 5, + 8, + 9, + 10, + 11, + 14, + 15, + 12, + 13, + 48, + 49, + 50, + 51, + 54, + 55, + 52, + 53, + 56, + 57, + 58, + 59, + 62, + 63, + 60, + 61, + 32, + 33, + 34, + 35, + 38, + 39, + 36, + 37, + 40, + 41, + 42, + 43, + 46, + 47, + 44, + 45, + 16, + 17, + 18, + 19, + 22, + 23, + 20, + 21, + 24, + 25, + 26, + 27, + 30, + 31, + 28, + 29 + ], + "Bell_phase_exponents": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 6, + 7, + 4, + 5, + 8, + 9, + 10, + 11, + 14, + 15, + 12, + 13, + 48, + 49, + 50, + 51, + 54, + 55, + 52, + 53, + 56, + 57, + 58, + 59, + 62, + 63, + 60, + 61, + 32, + 33, + 34, + 35, + 38, + 39, + 36, + 37, + 40, + 41, + 42, + 43, + 46, + 47, + 44, + 45, + 16, + 17, + 18, + 19, + 22, + 23, + 20, + 21, + 24, + 25, + 26, + 27, + 30, + 31, + 28, + 29 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + 12, + 0 + ], + [ + 4, + 0 + ] + ], + "denominator": 1, + "name": "CNOT21", + "numerator_sha256": "26fdce0c1667afd8e72ad5d7b396316148db3a95b03c9d35fdc53dcfb914d0a4" + }, + { + "Bell_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Bell_phase_exponents": [ + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "Pauli_labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44, + 45, + 46, + 47, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 58, + 59, + 60, + 61, + 62, + 63 + ], + "Pauli_signs": [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + "Sym2_Lambda2_traces": [ + [ + -36, + 0 + ], + [ + -28, + 0 + ] + ], + "denominator": 1, + "name": "central_i", + "numerator_sha256": "e5293becb85feb1b30aef67baf4beb62f9fa0b1b87c33b0cf4168e0e5c55955c" + } + ], + "ordered_pair_orbits": [ + { + "Arf": 0, + "dimension": 36, + "directed_generator_edges_checked": 23940, + "ordered_distinct_pairs_reached": 1260, + "sorted_pair_sha256": "d6374fa57b212bc23be5b4208189da7d9f2ee0b2a0e6d10c107ddeb886cbde3f" + }, + { + "Arf": 1, + "dimension": 28, + "directed_generator_edges_checked": 14364, + "ordered_distinct_pairs_reached": 756, + "sorted_pair_sha256": "391985c4680c74972252bf9f880c5a3fb078c2ce57af3585dc08417443229dcd" + } + ], + "parser_controls": [ + { + "name": "duplicate_JSON", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "duplicate JSON key", + "witness": {} + }, + { + "name": "floating_JSON", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "noninteger JSON number", + "witness": {} + }, + { + "name": "nonfinite_JSON", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "noninteger JSON number", + "witness": {} + } + ], + "predecessor_programs_executed": false, + "schema_version": 1, + "scope": "New actual-generator/Bell and ordered-pair evidence for two blocks; inherited table/group/m9/reciprocity/Gram premises; no full spectrum or endpoint claim.", + "source_manifest_sha256": "51d69b9daeefb8ac8b9c530605e17dad60e35e426d31652928b1dff29582fd81", + "source_sha256": { + "predecessor/PR6714-PROOF.md": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0", + "predecessor/PR6794-PROOF.md": "cff2a5c894f20f368ecb88410dbd29c8380144c46cfa7dac4428296725e50ef3", + "source/EXTERNAL.json": "eb64deffd68787fe12df7b745d98f3139f77c5ab7ecd41a86bd832db0c7ebe0a", + "source/table.json": "388d617a76e345774a8768f32a6a9bc6e94b87f9c8a5cf6712a95a5a3a945fcd", + "source/width-nine-input.json": "308b8dee094eb5481565ea89698ed5df69edeeecd4b63b4d78cb9cecdbe71c27" + }, + "status": "PASS_CLIFFORD_QUADRATIC_ORBIT_BLOCKS", + "transpose_orbits": [ + { + "Arf": 0, + "dimension": 36, + "labels": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 10, + 12, + 14, + 16, + 17, + 20, + 21, + 24, + 27, + 28, + 31, + 32, + 33, + 34, + 35, + 40, + 42, + 45, + 47, + 48, + 49, + 54, + 55, + 56, + 59, + 61, + 62 + ] + }, + { + "Arf": 1, + "dimension": 28, + "labels": [ + 9, + 11, + 13, + 15, + 18, + 19, + 22, + 23, + 25, + 26, + 29, + 30, + 36, + 37, + 38, + 39, + 41, + 43, + 44, + 46, + 50, + 51, + 52, + 53, + 57, + 58, + 60, + 63 + ] + } + ], + "transvection": { + "actual_Sym2_Lambda2_traces": [ + [ + 0, + 16 + ], + [ + 0, + 16 + ] + ], + "fixed_Pauli_labels": 32, + "fixed_form_counts": [ + 16, + 16 + ], + "fixed_forms_by_Arf": [ + [ + 1, + 3, + 5, + 7, + 17, + 21, + 27, + 31, + 33, + 35, + 45, + 47, + 49, + 55, + 59, + 61 + ], + [ + 9, + 11, + 13, + 15, + 19, + 23, + 25, + 29, + 37, + 39, + 41, + 43, + 51, + 53, + 57, + 63 + ] + ], + "generator": "S0", + "nontrivial_permutation_character_values": [ + 15, + 15 + ], + "quotient_rank_difference": 1 + }, + "witnessed_controls": [ + { + "name": "V_in_place_of_Vbar", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "Vbar conjugation is necessary", + "witness": { + "generator": "central_i", + "mismatch": { + "column": 0, + "left": [ + 0, + -1 + ], + "right": [ + 0, + 1 + ], + "row": 0 + }, + "theta": [ + -1, + 0 + ] + } + }, + { + "name": "conjugation_in_place_of_congruence", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "Bell action requires congruence", + "witness": { + "correct_form": 8, + "generator": "S0", + "input_form": 0, + "mismatch": { + "column": 1, + "left": [ + 1, + 0 + ], + "right": [ + -1, + 0 + ], + "row": 1 + }, + "wrong_form": 0 + } + }, + { + "name": "degree_alone_selects_wrong_35", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "source constituent degree/transvection identification", + "witness": { + "actual_Tt": -5, + "correct_m9": 1975, + "correct_row": 7, + "degree": 35, + "inherited_m9": 175, + "required_Tt": 15, + "wrong_published_row": 8 + } + }, + { + "name": "Y_assigned_to_symmetric_Arf0", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "transpose/Arf assignment", + "witness": { + "actual_Arf": 1, + "form": 9, + "mismatch": { + "column": 1, + "left": [ + 0, + 1 + ], + "right": [ + 0, + -1 + ], + "row": 0 + } + } + }, + { + "name": "tensor_Y_gauge_mislabeled_as_binary_dot", + "outcome": "REJECTED_FOR_INTENDED_REASON", + "reason": "wrong binary-dot Bell phase", + "witness": { + "canonical_phase": 0, + "form": 27, + "mismatch": { + "column": 3, + "left": [ + -1, + 0 + ], + "right": [ + 1, + 0 + ], + "row": 0 + }, + "scope": "Serialization/basis-gauge guard; the alternate phased matrix is not an illegal group element.", + "tensor_Y_phase": 2 + } + } + ] +} diff --git a/research/clifford-quadratic-orbit-blocks/SOURCE-PINS.json b/research/clifford-quadratic-orbit-blocks/SOURCE-PINS.json new file mode 100644 index 0000000000..8c10930096 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/SOURCE-PINS.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "files": [ + { + "local_path": "predecessor/PR6794-PROOF.md", + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "c6252da020819a08ef2b2ff14280146c43ad374c", + "source_path": "research/clifford-transvection-conditioning/PROOF.md", + "git_blob": "60a16b0578affc88657e8e79bb503ec9d2fa00a6", + "sha256": "cff2a5c894f20f368ecb88410dbd29c8380144c46cfa7dac4428296725e50ef3", + "bytes": 7156, + "mode": "100644", + "usage": "Inert mathematical provenance or retained source data; not executed or independently accepted." + }, + { + "local_path": "source/table.json", + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "c6252da020819a08ef2b2ff14280146c43ad374c", + "source_path": "research/clifford-transvection-conditioning/source/pr6714-table.json", + "git_blob": "01f56d329aec686e49dc18f83adfea47b7fa423e", + "sha256": "388d617a76e345774a8768f32a6a9bc6e94b87f9c8a5cf6712a95a5a3a945fcd", + "bytes": 44024, + "mode": "100644", + "usage": "Inert mathematical provenance or retained source data; not executed or independently accepted." + }, + { + "local_path": "source/width-nine-input.json", + "source_repository": "petalas/integer-mult-bounds", + "source_commit": "c6252da020819a08ef2b2ff14280146c43ad374c", + "source_path": "research/clifford-transvection-conditioning/source/pr6714-result.json", + "git_blob": "77a5c8b23b91ed215b41cd2181a245d3f7d2374e", + "sha256": "308b8dee094eb5481565ea89698ed5df69edeeecd4b63b4d78cb9cecdbe71c27", + "bytes": 5463, + "mode": "100644", + "usage": "Inert mathematical provenance or retained source data; not executed or independently accepted." + }, + { + "local_path": "predecessor/PR6714-PROOF.md", + "source_repository": "alephnan/integer-mult-bounds", + "source_commit": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0", + "source_path": "research/clifford-three-qubit-threshold/PROOF.md", + "git_blob": "9f89ee36a0a1a0bdda09582d88477e15674fda5e", + "sha256": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0", + "bytes": 17137, + "mode": "100644", + "usage": "Inert mathematical provenance or retained source data; not executed or independently accepted." + }, + { + "local_path": "source/EXTERNAL.json", + "source_repository": "alephnan/integer-mult-bounds", + "source_commit": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0", + "source_path": "research/clifford-three-qubit-threshold/EXTERNAL.json", + "git_blob": "3fe07503d342e91a1cc0b35061b0ac84de31eb0e", + "sha256": "eb64deffd68787fe12df7b745d98f3139f77c5ab7ecd41a86bd832db0c7ebe0a", + "bytes": 1995, + "mode": "100644", + "usage": "Inert mathematical provenance or retained source data; not executed or independently accepted." + } + ] +} diff --git a/research/clifford-quadratic-orbit-blocks/SOURCES.json b/research/clifford-quadratic-orbit-blocks/SOURCES.json new file mode 100644 index 0000000000..c64cc0b47d --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/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/clifford-quadratic-orbit-blocks/TASK.json b/research/clifford-quadratic-orbit-blocks/TASK.json new file mode 100644 index 0000000000..8a0f8021d2 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/TASK.json @@ -0,0 +1,148 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a", + "original_card": { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "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": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Two actual width-ten even-sector irreducible blocks for the pinned Gaussian-dyadic three-qubit Clifford group: Sym\u00b2V and \u039b\u00b2V, via phase-correct Bell/quadratic-orbit permutation intertwiners and inherited width-nine source multiplicities.", + "scope_change_reason": "Take6794 actualstabilizer-decomposition request and6822 nextquestion, narrowedto twoexplicit modules. A bounded source-bound algebraic audit, not a Lean proposition or selected physical-assumption discharge.", + "bottleneck_link": "Replace part of an optimistic character relaxation with actual irreducible multiplicity data before attempting full spectral endpoint claims.", + "budget_minutes": 120, + "stop_rule": "Stop after these two modules and exact width-ten blocks, with bounded generator/ordered-pair corroboration. Stop if identity fails or exact equivalent covers it. No full group census/even-sector table/endpoints/generalwidth classification or native construction. Reserve at least30 actual minutes after final freeze.", + "outcome": "partial", + "evidence": "Written phase-correct actualSym\u00b2V/\u039b\u00b2V irreducibility/intertwiner/decomposition, sourceboundm10=2244/2159 and\u03bb176715/32768,874395/131072. FirstnewdiagnosticPASS0.3259265s23.84375MiB, code/proofunchanged. Full21547Bpacket retained; no fullspectrum/endpoint/nativeclaim.", + "author": "ToikY with substantial OpenAI Codex assistance", + "ai_assistance": "Source-aware root recipe/proof/implementation/overlap/metadata and related-role challenges; rejected ordinaryH/omega brainstorm preserved. Not blind discovery, human or kernel acceptance.", + "selection": { + "kind": "explicit_handoff", + "source_pr": 6794, + "source_head": "c6252da020819a08ef2b2ff14280146c43ad374c", + "foundation_pr": 6714, + "foundation_head": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0", + "excluded_current_pr": 6822, + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/6794#issuecomment-6700937276", + "hub_pointer": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19452883", + "picker_draw": null + }, + "family_gate": { + "decision": "NARROW_BOUNDED_AUDIT", + "scope": "Two missing actual representation-block implications. No supplier expansion or physical construction.", + "proved_costs": [], + "constructively_upper_bounded_physical_costs": [], + "unknown_costs": [ + "nativecaller", + "preparation", + "routing/chronology", + "precision/ownership/restoration/stock", + "completephysicalrecursiveinvoice" + ] + }, + "model": { + "coefficient_ring": "D=Z[i,1/2]", + "G": "All unitary three-qubit Clifford matrices with entries inD", + "scalar_kernel": "mu4, z=iI", + "natural_dimension": 8, + "tensor_width": 10, + "ordinary_H_or_scalar_omega_allowed": false, + "legal_source_generators": [ + "PauliX/Z", + "S", + "Rx=((1+i)I+(1-i)X)/2", + "CNOT", + "central iI" + ] + }, + "source_status": "Five exact package-local inert source prose/numerical files75775B, plus canonical workflow/legal provenance. No predecessor scientific engine imported/run; inherited group/table/width-nine/Gram premises not independently replayed.", + "physical_obligations": { + "actual_native_caller": null, + "preparation_ownership": null, + "routing_chronology": null, + "precision_stock_restoration": null, + "complete_physical_recursive_invoice": null + }, + "open_questions": [ + { + "question": "Which remaining even-sector irreducibles determine the actual width-ten spectral endpoints?", + "why_it_matters": "Two actual blocks do not classify the full spectrum or establish relaxed-extremum attainment.", + "first_step": "Name one uncovered quadratic-form stabilizer representation and prove its exact extension/intertwiner before inheriting width-nine source multiplicities.", + "blocked_by": "The remaining stabilizer representations and possible eigenvalue coincidences are not computed; no follow-on reservation." + }, + { + "question": "Can one concrete native caller use the source-bound conditioning result at a complete cost?", + "why_it_matters": "Algebraic Gram eigenvalues do not provide a physical multiplier or implement the selected assumptions.", + "first_step": "Bind the caller and every preparation/routing/precision/recovery/ownership/restoration/stock charge to the actual alphabet.", + "blocked_by": "No native caller or complete physical invoice is supplied." + } + ] +} diff --git a/research/clifford-quadratic-orbit-blocks/VERIFY.json b/research/clifford-quadratic-orbit-blocks/VERIFY.json new file mode 100644 index 0000000000..c05fc7a7b1 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/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 exact Gaussian-dyadic generator/Bell congruence, complete phase-cancelling intertwiners, ordered-pair orbits and source-bound two-block certificate; no predecessor engine or full group census." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Same complete typed retained packet and explicit optimized-mode source/result/phase guards." + } + ] +} diff --git a/research/clifford-quadratic-orbit-blocks/predecessor/PR6714-PROOF.md b/research/clifford-quadratic-orbit-blocks/predecessor/PR6714-PROOF.md new file mode 100644 index 0000000000..9f89ee36a0 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/predecessor/PR6714-PROOF.md @@ -0,0 +1,430 @@ +# The three-qubit Clifford tensor threshold is ten + +This is a scoped algebraic theorem about the complete Gaussian-dyadic +three-qubit Clifford alphabet. It gives no new multiplication exponent, +physical supplier, or implementation of the five assumptions retained by +the selected construction. Classical finite-group representation theory +and the cited character table are premises; the proof is not a proof-assistant +formalization or independent human review. + +## 1. Statement and conventions + +Let `D = Z[i,1/2]`, and let `G` be the group of all unitary three-qubit +Clifford matrices with entries in `D`. Its natural representation `V` has +dimension eight. Let `z=iI`. The scalar subgroup is + + Z = = {I,iI,-I,-iI}. + +Let `P` be the Pauli subgroup generated by `z` and the three pairs `X_j,Z_j`. +Then `|P|=256`, `G/P = Sp(6,2) = S`, and + + |S| = 1,451,520, + |G/Z| = 64 |S| = 92,897,280, + |G| = 4 |G/Z| = 371,589,120. + +The usual Pauli and symplectic conventions are those of the retained +pointwise-faithfulness and two-qubit-centre packages. The Gaussian-dyadic +group has scalar kernel `mu_4`, not `mu_8`. Indeed, if `(a+bi)/2^k` has +modulus one, successive parity division in `a^2+b^2=2^(2k)` reduces it to +one of the four Gaussian units. The Gaussian-dyadic gates `S`, +`((1+i)I+(1-i)X)/2`, and CNOT realize the standard symplectic generators; +thus the quotient is the full `Sp(6,2)`. The Pauli action determines a +Clifford up to scalar. + +Choose one unitary representative `U_a` for each `a in G/Z`, with `U_1=I`. +Define + + H_f(a,b) = (tr(U_a^* U_b)/8)^f, f = 1,2,... . + +This is the Gram matrix of `U_a^(tensor f)/8^(f/2)` in Hilbert-Schmidt +space. Changing the representatives conjugates `H_f` by a diagonal +unitary matrix and does not change its rank or spectrum. + +**Theorem.** The least width at which this projective alphabet is linearly +independent is exactly **ten**. Equivalently, its least eventual pointwise +threshold is + + T(3) = 10. + +At width nine the nullity is exactly `56^2 = 3,136`, so + + rank H_9 = 92,894,144. + +For every integer `f >= 10`, the following additional, nonoptimal bounds hold: + + (945/262144) I <= H_f <= (762615/32768) I. (1) + +The resulting Gram condition-number bound is 6,456. We do not claim sharp +spectral constants. In particular, the threshold is not the extrapolated +value `4n+1=13` suggested by the one- and two-qubit cases. + +## 2. Why tensor independence is an irreducible-support question + +For each `r mod 4`, let `A_r` be the central-character ideal of `C[G]` on +which `z` acts as `i^r`. Its dimension is `|G/Z|`, and one representative +per projective class gives a basis after projection to this ideal. +The representation `V^(tensor f)` annihilates the other three ideals. + +By semisimplicity, + + A_r = direct_sum_{rho : rho(z)=i^r I} End(rho). + +The representation of `A_r` is injective exactly when every irreducible +in this sector occurs. A missing irreducible of dimension `d` removes +an entire matrix block of dimension `d^2`. Thus + + rank H_f = sum_{rho occurring in V^(tensor f)} (dim rho)^2. (2) + +If `m_rho(f)` is its multiplicity, the normalized Gram eigenvalue on its +regular matrix block is + + lambda_rho(f) = |G/Z| m_rho(f) / (8^f dim rho). (3) + +One way to check the normalization is to use central convolution on all +of `G`, whose eigenvalue is `|G| m_rho(f)/dim rho`. Combining the four +scalar lifts multiplies the projective Gram by `4*8^f`; dividing gives +(3). The regular multiplicity is `(dim rho)^2`, not four times that value. + +## 3. The odd central sector and a smaller character calculation + +The Pauli group has a unique irreducible with `z` acting by `i`, namely +the eight-dimensional restriction of `V`. This follows directly from +the usual irreducible representation of the three Pauli pairs; its +matrix algebra has dimension 64. Consequently every irreducible of `G` +in central sector `i` has the unique form + + V tensor sigma, sigma in Irr(S). (4) + +For completeness, for such a representation `R`, the multiplicity space +`Hom_P(V,R)` carries the honest quotient action + + g . phi = R(g) phi V(g)^(-1). + +Pauli elements act trivially on this space. Evaluation identifies +`R` with `V tensor Hom_P(V,R)`, and irreducibility on one side is equivalent +to irreducibility of the multiplicity space. No splitting of `G` over `P` +is being assumed. The actual natural representation supplies the extension +needed in (4). + +Let `s in S`, and put `d(s)=dim_F2 ker(s-I)`. Among the 64 projective +Pauli lifts of `s`, exactly `2^(6-d(s))` have nonzero trace; on each such +lift `g`, + + |tr V(g)|^2 = 2^d(s). (5) + +To recall the argument, conjugation on the Hermitian Pauli basis is a +signed permutation. Its trace is `|tr V(g)|^2`. The signs on the fixed +label space form a binary character, so their sum is zero or `2^d`. +Multiplication by Paulis runs through all its characters equally often. +In particular there is always a nonzero-trace lift. + +For a Gaussian-dyadic number of squared modulus `2^d`, its fourth power is + + (tr V(g))^4 = (-1)^d 2^(2d). (6) + +This includes the phase: writing the number as `(a+bi)/2^k`, the equation +`a^2+b^2=2^(d+2k)` implies that, after removing common powers of two, +either one coordinate is zero or the coordinates have equal absolute +value. The two cases give the sign in (6). + +For `f=4t+1`, write + + V^(tensor f) = V tensor W_f. + +The quotient representation `W_f` is honest, and the character product +on a nonzero-trace lift gives + + chi_W_f(s) = (-1)^(dt) 2^(2dt). (7) + +In particular, + + chi_W_9(s) = 2^(4d(s)). (8) + +This is also the permutation character of `S` acting on ordered +four-tuples of vectors in `F_2^6`. Thus the width-nine input to the proof +is an ordinary 30-character calculation for `Sp(6,2)`, rather than a +92,897,280-by-92,897,280 Gram calculation. + +## 4. Exact width-nine decomposition + +We use the published character table of Chin-Yen Lee, Wei-Hsuan Yu, +Yung-Ning Peng and Ching-Jui Lai, [arXiv:2309.14850v2](https://arxiv.org/html/2309.14850v2#S6.SS3), Section 6.3, +and its Section 5.2 identification of the adjoint character as +`1 + chi_10`. The package retains the exact transcribed table and the +class-fibre extraction. Inflated characters are those trivial on the +64-element projective Pauli subgroup. The executable checks character +orthogonality, class and degree sums, the quotient extraction, fixed-space +trace data, and every integer inner product below. Those checks validate +the transcription and calculation; they do not independently reconstruct +the published character table from group multiplication. + +More explicitly, the nonidentity projective Paulis constitute one +63-element conjugacy class. A character is trivial on this subgroup +exactly when its value on that class equals its degree: equality in the +unitary trace bound forces the matrix to be the identity. These are +precisely the inflated quotient irreducibles. Two source classes have the +same quotient class exactly when all these characters agree, since +irreducible characters separate conjugacy classes. Each quotient class +size is the sum of its source class sizes divided by 64. Finally, the +maximum of the adjoint value `1+chi_10` over a quotient fibre is `2^d` +by (5). This identifies the fixed-space data used in (8), including the +63-element transvection class, without inferring `d` from class order alone. + +Taking inner products of (8) with the quotient characters gives the +following complete list. Repeated degrees denote distinct irreducibles, +in their retained source order. + +| Degree | Multiplicity in `W_9` | +|---:|---:| +| 1 | 269 | +| 7 | 0 | +| 15 | 85 | +| 21 | 35 | +| 21 | 840 | +| 27 | 1890 | +| 35 | 1975 | +| 35 | 175 | +| 56 | 28 | +| 70 | 350 | +| 84 | 1407 | +| 105 | 210 | +| 105 | 2625 | +| 105 | 1575 | +| 120 | 3900 | +| 168 | 4410 | +| 189 | 945 | +| 189 | 567 | +| 189 | 2835 | +| 210 | 5250 | +| 210 | 2625 | +| 216 | 1728 | +| 280 | 5600 | +| 280 | 1400 | +| 315 | 1575 | +| 336 | 2940 | +| 378 | 2835 | +| 405 | 6075 | +| 420 | 5250 | +| 512 | 5440 | + +The multiplicity-weighted dimensions sum to `8^8=16,777,216`. Let `sigma_0` denote the sole +missing character, of degree seven. On a symplectic transvection `tau`, + + chi_sigma_0(tau) = -5. (9) + +This is the class of size 63 with fixed-space dimension five. The +nonzero multiplicities in the table also satisfy + + (1/2) dim sigma <= m_sigma(9) <= 269 dim sigma. (10) + +The only missing irreducible in `V^(tensor 9)` is therefore +`rho_0=V tensor sigma_0`, of dimension 56. Equation (2) proves the +claimed nullity and rank. + +There is an explicit null witness. For a projective representative `U_a`, +let `s_a` be its symplectic image and define + + b_a = chi_rho_0(U_a^(-1)) + = conjugate(tr V(U_a) * chi_sigma_0(s_a)). + +Then + + sum_a b_a U_a^(tensor 9) = 0. (11) + +Indeed, the central primitive idempotent + + (56/|G|) sum_{g in G} chi_rho_0(g^(-1)) [g] + +acts as zero in `V^(tensor 9)`. Grouping its four scalar lifts gives +(11), since their factors `i^(-j)` and `i^(9j)` cancel. This is a +nonzero coefficient vector: its coefficient at the identity is 56. +It is a width-nine relation, not an all-width identity. + +## 5. The even sector is controlled by quadratic forms + +Consider any irreducible `mu` of `G` with `mu(z)=-I`, the sector of +`V^(tensor 10)`. Its restriction to `P` is a sum of one-dimensional +characters because `[P,P]=<-I>` and `mu(-I)=I`. + +Write a binary label as `v=(a,b)` and use the Hermitian Pauli convention + + W_v = i^(a.b) X^a Z^b. + +The one-dimensional characters with `z` acting by `-1` are indexed by +the 64 quadratic forms with polar form the standard symplectic form: + + Q_(alpha,beta)(a,b) = a.b + alpha.a + beta.b, + lambda_Q(W_v) = (-1)^Q(v). + +In a Clifford conjugation `W_v -> +/- W_(s v)`, the sign has no effect +on `lambda_Q`, since it sends `-I` to one. The quotient therefore acts +on these characters by its ordinary action on quadratic forms. + +There are exactly two orbits, distinguished by Arf invariant, + + Arf Q_(alpha,beta) = alpha.beta. + +Their sizes are 36 and 28. This is the standard symplectic classification +of nondegenerate binary quadratic forms: choosing successive hyperbolic +pairs gives one normal form for each Arf value. The counts also follow +directly by summing over `alpha,beta`. + +Since `mu` is irreducible, its Pauli character spaces form one transitive +orbit and have a common dimension `a>=1`. Hence for one `N in {28,36}`, + + mu restricted to P = a sum_{Q in orbit} lambda_Q, + dim mu = N a. (12) + +For a nonzero vector `v`, the symplectic transvection is + + tau_v(x) = x + omega(x,v) v. + +The quadratic identity gives + + Q(tau_v x) = Q(x) + omega(x,v)(Q(v)+1). + +Thus a form is fixed exactly when `Q(v)=1`. Each Arf orbit has exactly +16 such forms. For example, use symplectic coordinates with `v=e_1`. +Then `alpha_1=1`; the four coordinates +`alpha_2,alpha_3,beta_2,beta_3` are arbitrary, and `beta_1` is uniquely +fixed by the prescribed Arf invariant. + +Any Clifford lift `g` of this transvection permutes the Pauli character +spaces. Only the sixteen fixed spaces contribute to its trace. Since +the representation can be made unitary, each contributes absolute trace +at most `a`. Consequently + + |chi_mu(g)| <= 16 a. (13) + +This bound uses neither the character table of the even central sector +nor extensions of its stabilizer representations. + +## 6. Every irreducible occurs at width ten + +Suppose, for contradiction, that `mu` is missing from `V^(tensor 10)`. +Tensor reciprocity gives + + = . + +The representation on the right has central character `i`. The sole +irreducible absent from `V^(tensor 9)` is `rho_0`. All multiplicities are +nonnegative integers, so absence forces + + conjugate(V) tensor mu = m rho_0, m >= 1. + +Dimensions give `7m=Na`. Take `g=S` on the first qubit and the identity +on the other two. Its symplectic image is a transvection and +`tr V(g)=4(1+i)` is nonzero. The character identity and (9) imply + + |chi_mu(g)| = 5m = (5N/7)a. + +For `N=28` this is `20a`; for `N=36` it is `180a/7`. Both exceed `16a`, +contradicting (13). Therefore no even-sector irreducible is missing. +By Section 2, `H_10` is positive definite. + +This argument is also a useful check against a phase error: conjugate `V`, +not `V`, is used in reciprocity, and the relevant Pauli character orbit is +the quadratic-form orbit for central character `-1`. + +## 7. Quantitative bounds and every larger width + +The same reasoning gives (1) without computing the full even-sector +spectrum. Decompose + + conjugate(V) tensor mu = sum_sigma n_sigma (V tensor sigma), + d_mu := dim mu = sum_sigma n_sigma dim sigma. + +Let `n_0` be the coefficient of the missing degree-seven character and +put `R=d_mu-7n_0`. At the transvection lift used above, the character +identity and the elementary bound +`|chi_sigma(tau)|<=dim sigma` give + + 12n_0-d_mu + = 5n_0-R + <= |sum_sigma n_sigma chi_sigma(tau)| + = |chi_mu(g)| + <= 16a. + +The first inequality is valid even when its left side is negative. +Using `d_mu=Na` and `N in {28,36}` yields + + R >= a(5N-112)/12 >= d_mu/12. + +Reciprocity and (10) now show + + d_mu/24 <= m_mu(10) <= 269 d_mu. + +Substituting into (3) gives precisely (1) at width ten. The lower bound +also proves positivity directly. + +Finally, + + H_(f+1) = H_f Hadamard H_1. + +The Schur product theorem and the unit diagonal of `H_1` imply + + alpha I <= H_f <= beta I + => alpha I <= H_(f+1) <= beta I. + +This proves (1), hence independence, at every `f>=10`. If any smaller +positive width were independent, the same Schur step would make width +nine independent, contrary to Section 4. The threshold is therefore +exactly ten, not just an upper bound. + +## 8. Four fixed-residual tests with exact phases + +Let a fixed residual in `C[G]` have coefficients `c_(a,j)` on the exact +operators `i^j U_a`, after equal operators are combined. For `r mod 4`, set + + beta_(a,r) = sum_{j=0}^3 c_(a,j) i^(jr). + +At width `f`, its operator evaluation is + + sum_a beta_(a,f mod 4) U_a^(tensor f). + +Pointwise independence at the four widths `10,11,12,13` makes these +evaluations zero exactly when all four sets of `beta` coefficients are +zero. Fourier inversion then gives `c_(a,j)=0` for every exact operator. +Consequently the following are equivalent for a fixed residual: + +1. Every exact-operator coefficient vanishes. +2. Its evaluation vanishes at every positive tensor width. +3. Its evaluations vanish at widths 10, 11, 12 and 13. + +If `M=sum_(a,j)|c_(a,j)|^2`, Parseval and (1) imply that at least one of +those four evaluations has normalized squared Hilbert-Schmidt norm at +least `(945/262144) M`. Coefficients must be fixed for this four-test +statement; pointwise independence itself allows coefficients to depend +on the chosen width. + +Four residue classes remain necessary for unrestricted fixed residuals: +`sum_j i^(-rj)[i^j I]` vanishes outside residue `r` and is nonzero in that +residue. The four-test count and the scalar Fourier argument are retained +predecessor principles; this theorem supplies the earlier sufficient window. + +## 9. Scope and attribution + +The alphabet is the full projective three-qubit Clifford group, with arbitrary +complex coefficients at a fixed width. The theorem is not a statement about +arbitrary sums of Cliffords as individual alphabet elements, operators coupling +tensor columns, nonlinear rounded gates, or nonunitary stabilizer maps. +It supplies no paid-call bound without a separate source-bound caller argument. +The selected conditional multiplication result and its five assumptions are +unchanged. + +Ali Romman's pointwise-faithfulness package supplies the general Clifford +framework, trace distribution, phase-residue interpretation, and open sharp +threshold question. MatShep's one- and two-qubit packages supply the earlier +sharp cases and the Schur-propagation method. The linear-lower-bound package +records the unresolved three-qubit case. The authors of arXiv:2309.14850 +supply the published character table and adjoint identification; their table +is a cited mathematical input, not newly constructed here. Pauli representation +theory, tensor reciprocity, character orthogonality, binary quadratic-form +classification, central idempotents and the Schur product theorem are classical. + +The new contribution is the exact width-nine decomposition and its missing +block, the even-sector transvection argument proving full support at ten, +and their quantitative and fixed-residual consequences. Prepared with +substantial OpenAI Codex assistance and separate agent proof/checking work. +No independent human acceptance or proof-kernel certification is claimed. +New material is Apache-2.0; retained sources keep their attribution and license. diff --git a/research/clifford-quadratic-orbit-blocks/predecessor/PR6794-PROOF.md b/research/clifford-quadratic-orbit-blocks/predecessor/PR6794-PROOF.md new file mode 100644 index 0000000000..60a16b0578 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/predecessor/PR6794-PROOF.md @@ -0,0 +1,178 @@ +# A transvection certificate for three-qubit conditioning + +## Statement and inherited mathematical inputs + +Use the full Gaussian-dyadic three-qubit Clifford alphabet and conventions of +[alephnan's PR6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714), +at head `f7f32a18dde54e67624a9ed9cc7e1b266d9585c0`. For representatives +`U_a` of its 92,897,280 projective classes, put + +\[ + H_f(a,b)=\left(\operatorname{tr}(U_a^*U_b)/8\right)^f. +\] + +For every integer `f >= 10`, this package proves the sufficient bounds + +\[ + \boxed{\frac{2835}{131072}I\preceq H_f + \preceq\frac{2287845}{131072}I.} \tag{1} +\] + +Consequently the spectral condition number is at most **807**. +The predecessor's sufficient bounds were `945/262144` and `762615/32768`, +with ratio 6,456. The lower bound in (1) is six times larger and the upper +bound is three quarters as large. No optimality for the actual spectrum is claimed. + +The following are cited predecessor results, rather than claims reproved here. +They are in its [PROOF.md, Sections 2 through 7](https://github.com/CrocSwap/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md). + +1. Let `V` be the natural eight-dimensional representation, and `sigma` run + over the thirty irreducible characters of `Sp(6,2)`. The odd central-sector + irreducibles are `V tensor sigma`. Their multiplicities in `V^(tensor 9)` + are the nonnegative integers `m_sigma` retained in the source result. +2. If `mu` is an even-sector irreducible relevant at width ten, then + + \[ + \overline V\otimes\mu + =\bigoplus_\sigma n_\sigma(V\otimes\sigma),\qquad n_\sigma\ge0. + \] + + Write `d_sigma = dim sigma` and `d = dim mu`. Dimensions and reciprocity give + + \[ + d=\sum_\sigma n_\sigma d_\sigma,\qquad + m_\mu(10)=\sum_\sigma n_\sigma m_\sigma. \tag{2} + \] + +3. There is `N` equal to 28 or 36 and an integer `a >= 1` with `d=Na`. + For a transvection `tau` of `Sp(6,2)`, set + + \[ + T=\sum_\sigma n_\sigma\chi_\sigma(\tau). + \] + + Then `|T| <= 16a = 16d/N`. This follows because exactly sixteen quadratic + forms in either Pauli-character orbit are fixed by a transvection. + In the source's phase convention, the quotient-character sum differs from + the character of `mu` at its Clifford lift by a scalar of absolute value one. +4. The eigenvalue on the regular matrix block of `mu` is + + \[ + \lambda_\mu(10)=\frac{92897280}{8^{10}} + \frac{m_\mu(10)}{d}. \tag{3} + \] + + Also `H_(f+1) = H_f circ H_1`, where `circ` is the Schur product, + `H_1` is positive semidefinite, and its diagonal is one. + +The exact source numerical files are retained unchanged. Their origin and hashes +are in [ORIGIN.json](ORIGIN.json). The published character table is due to +Chin-Yen Lee, Wei-Hsuan Yu, Yung-Ning Peng and Ching-Jui Lai. This proof uses +the predecessor's identification and multiplicities as inputs. It does not +reconstruct the table, audit that identification, or rerun its decomposition. + +## The new finite certificate + +For every one of the thirty types, write `t_sigma = chi_sigma(tau)`. The +retained data satisfy the two integer inequalities + +\[ + 4m_\sigma-5d_\sigma-7t_\sigma\ge0,\qquad + 1345d_\sigma+1883t_\sigma-12m_\sigma\ge0. \tag{4} +\] + +These are the new supporting lines. The verifier reads the cited width-nine +multiplicities and the transvection column, evaluates every residual in (4) +exactly, and prints all thirty pairs. This is a finite arithmetic certificate +for new inequalities in the predecessor data, rather than another verification +of its threshold or multiplicity calculation. + +The source row numbers and the three tight data points explain the constants: + +| source row | `d_sigma` | `t_sigma` | `m_sigma` | +| --- | ---: | ---: | ---: | +| 1 | 1 | 1 | 269 | +| 2 | 7 | -5 | 0 | +| 9 | 56 | -24 | 28 | + +The lower supporting line passes through normalized rows 2 and 9. The upper +supporting line passes through normalized rows 1 and 2. Checking only these +three points would be insufficient; (4) is checked for **every** type. + +Multiply (4) by the nonnegative integers `n_sigma` and sum. By (2), + +\[ + \frac54d+\frac74T\le m_\mu(10) + \le\frac{1345}{12}d+\frac{1883}{12}T. \tag{5} +\] + +Both slopes are positive. Applying `-16d/N <= T <= 16d/N` gives + +\[ + \left(\frac54-\frac{28}{N}\right)d + \le m_\mu(10) + \le\left(\frac{1345}{12}+\frac{7532}{3N}\right)d. \tag{6} +\] + +Thus the two orbit-specific intervals for `m_mu(10)/d` are + +| `N` | lower bound | upper bound | +| --- | ---: | ---: | +| 28 | 1/4 | 807/4 | +| 36 | 17/36 | 19637/108 | + +The first interval contains the second. Since +`92897280/8^10 = 2835/32768`, (3) proves (1) at width ten. + +For propagation, if `alpha I <= H_f <= beta I`, Schur positivity gives + +\[ + (H_f-\alpha I)\circ H_1\succeq0,\qquad + (\beta I-H_f)\circ H_1\succeq0. +\] + +The unit diagonal means `I circ H_1=I`. Therefore the same interval holds at +`f+1`, proving (1) for every `f >= 10`. This is a written universal implication +from the stated representation-theoretic inputs, not a finite-width extrapolation. + +## What is sharp, and what is still open + +The two bounds in (6) are sharp for the following **relaxation only**. Assign +arbitrary nonnegative weights `x_sigma` summing to one, retain the thirty points + +\[ + (r_\sigma,c_\sigma)=(t_\sigma/d_\sigma,m_\sigma/d_\sigma), + \qquad \left|\sum_\sigma x_\sigma r_\sigma\right|\le16/N, +\] + +and minimize or maximize `sum x_sigma c_sigma`. The following explicit mixtures +attain all four bounds; weights refer to the indicated source rows. + +| `N` | extremum | nonzero weights | +| --- | --- | --- | +| 28 | minimum | row 2: 1/2; row 9: 1/2 | +| 28 | maximum | row 1: 3/4; row 2: 1/4 | +| 36 | minimum | row 2: 1/18; row 9: 17/18 | +| 36 | maximum | row 1: 73/108; row 2: 35/108 | + +Together with (4), these mixtures prove the relaxed optimum, including its +orientation at the two ends of the trace interval. The independent primal route +in the verifier lists every simplex vertex in the trace slab and every intersection +of a simplex edge with its two bounding hyperplanes. These cover the vertices: +at a vertex, at most two weights can be positive since there is the sum constraint +and at most one active trace constraint. If two trace coordinates coincide, a +nontrivial edge interior is not a vertex. All arithmetic is rational. + +The relaxation discards additional representation and multiplicity constraints. +Its attaining mixtures are not claimed to come from any actual irreducible `mu`. +In particular **807 is a sufficient uniform bound, not the exact condition +number**, and neither endpoint is claimed to be an actual eigenvalue. + +## Scope + +This is a scoped native-algebra conditioning theorem with exact finite +corroboration. It does not improve the already proved threshold ten. It supplies +no new paid-call construction, recursive invoice, physical implementation, +selected supplier admission or multiplication exponent. All five selected +framework assumptions retain their status. Independent human and formal +proof-kernel review are unclaimed. diff --git a/research/clifford-quadratic-orbit-blocks/source/EXTERNAL.json b/research/clifford-quadratic-orbit-blocks/source/EXTERNAL.json new file mode 100644 index 0000000000..3fe07503d3 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/source/EXTERNAL.json @@ -0,0 +1,31 @@ +{ + "schema": "external-mathematical-data/v1", + "source": { + "title": "On character table of Clifford groups", + "authors": [ + "Chin-Yen Lee", + "Wei-Hsuan Yu", + "Yung-Ning Peng", + "Ching-Jui Lai" + ], + "arxiv": "2309.14850v2", + "url": "https://arxiv.org/html/2309.14850v2", + "section": "6.3", + "retrieved_utc": "2026-11-04", + "html_sha256": "02e0adebe50fcb4ff3cb1112600094d77c9457c45707df041486cbb4491c2a2e", + "description": "Numerical mathematical table entries extracted from six HTML panels, in published character and conjugacy-class order. No article prose is redistributed.", + "tex_source_url": "https://arxiv.org/src/2309.14850v2", + "tex_sha256": "caa1e0449ef7575fc4c516238e939effb309038c45ae6f3d41f64206b9619de3", + "source_gzip_sha256": "c0b319313270000da28a9dd5c8358144dd613285ad7d6cdfabb1c9e409ab84f7", + "cross_check": "All 4489 numerical entries independently extracted from original TeX agree with the HTML transcription." + }, + "table_sha256": "388d617a76e345774a8768f32a6a9bc6e94b87f9c8a5cf6712a95a5a3a945fcd", + "identifications": { + "projective_group": "C_3 in the paper; quotient of the finite Gaussian-dyadic Clifford group by scalar fourth roots", + "adjoint": "Section 5.2: conjugation representation M_8 has character chi_1 + chi_10", + "normal_Pauli_subgroup": "Section 5.2 and Theorem 5.5: unique proper nontrivial normal subgroup has order64; the identity and class2 of size63", + "character_table": "Section6.3, characters1..67 and classes1..67 in published order" + }, + "reproduce_extraction": "python -B research/clifford-three-qubit-threshold/extract_table.py /path/to/2309.14850v2.html", + "scope": "The published character-table identification is cited, not independently reconstructed. Orthogonality and integrality checks detect corruption but do not establish that an abstract array is the character table of a named group. Only numerical mathematical facts are included, not article text." +} diff --git a/research/clifford-quadratic-orbit-blocks/source/table.json b/research/clifford-quadratic-orbit-blocks/source/table.json new file mode 100644 index 0000000000..01f56d329a --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/source/table.json @@ -0,0 +1,4649 @@ +{ + "schema": "published-character-table/v1", + "source": { + "title": "On character table of Clifford groups", + "authors": [ + "Chin-Yen Lee", + "Wei-Hsuan Yu", + "Yung-Ning Peng", + "Ching-Jui Lai" + ], + "arxiv": "2309.14850v2", + "url": "https://arxiv.org/html/2309.14850v2", + "section": "6.3", + "retrieved_utc": "2026-11-04", + "html_sha256": "02e0adebe50fcb4ff3cb1112600094d77c9457c45707df041486cbb4491c2a2e", + "description": "Numerical mathematical table entries extracted from six HTML panels, in published character and conjugacy-class order. No article prose is redistributed." + }, + "order": 92897280, + "adjoint_character_rows": [ + 1, + 10 + ], + "pauli_nonidentity_class": 2, + "characters": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1 + ], + [ + 7, + 7, + -2, + 1, + 3, + 3, + 3, + 3, + 4, + 4, + -3, + -3, + -3, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + -1, + -1, + -1, + 2, + 2, + 1, + 1, + -1, + -1, + -5, + -5, + -5, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 3, + 3, + 2, + 0, + 2, + 2, + 0, + 0, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -2, + -2, + -2, + -2, + -2, + 0 + ], + [ + 15, + 15, + -3, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + -2, + -2, + -3, + -3, + -3, + 7, + 7, + 7, + -2, + -2, + 3, + 3, + 1, + 1, + -5, + -5, + -5, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + -1, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 3, + 3, + 3, + -1, + -1, + 1, + 1, + 1, + 1, + 0, + -2, + -2, + -2, + 0, + 0, + 1 + ], + [ + 21, + 21, + 3, + 0, + 5, + 5, + 5, + 5, + 6, + 6, + -3, + -3, + -3, + 2, + 2, + 2, + 0, + 0, + -3, + -3, + -3, + 5, + 5, + 5, + 2, + 2, + 0, + 0, + 2, + 2, + -11, + -11, + -11, + -2, + -2, + -3, + -3, + -3, + -3, + 0, + 0, + 1, + 1, + -1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -2, + -2, + -2, + 0, + 0, + 0 + ], + [ + 21, + 21, + 3, + 0, + 1, + 1, + 1, + 1, + 6, + 6, + 3, + 3, + 3, + -2, + -2, + -2, + 0, + 0, + -1, + -1, + -1, + -3, + -3, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 9, + 9, + 9, + 0, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + 5, + 5, + 3, + -1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 0, + 0, + 0, + 2, + 2, + 0 + ], + [ + 27, + 27, + 0, + 0, + 7, + 7, + 7, + 7, + 9, + 9, + 5, + 5, + 5, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 3, + 3, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 15, + 15, + 15, + 0, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 3, + 3, + 0, + 0, + 2, + 2, + 0, + 0, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + 3, + 3, + 3, + 1, + 1, + -1 + ], + [ + 35, + 35, + -1, + -1, + 7, + 7, + 7, + 7, + 5, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 5, + 5, + 11, + 11, + 11, + -1, + -1, + 2, + 2, + 2, + 2, + 15, + 15, + 15, + 0, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + -1, + -1, + 3, + 3, + 3, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 3, + 3, + 3, + -1, + -1, + 0 + ], + [ + 35, + 35, + -1, + -1, + -5, + -5, + -5, + -5, + 5, + 5, + -1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + 3, + 3, + 3, + -3, + -3, + 2, + 2, + 0, + 0, + -5, + -5, + -5, + -2, + -2, + 3, + 3, + 3, + 3, + 0, + 0, + 7, + 7, + 3, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + -1, + -1, + 1, + 1, + -1, + -1, + -1, + -1, + 0, + 1, + 1, + 1, + -1, + -1, + 0 + ], + [ + 56, + 56, + 2, + -1, + 8, + 8, + 8, + 8, + 11, + 11, + -4, + -4, + -4, + -1, + -1, + -1, + -1, + -1, + 4, + 4, + 4, + -8, + -8, + -8, + 1, + 1, + 2, + 2, + -2, + -2, + -24, + -24, + -24, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -3, + -3, + -3, + 1, + 1, + 0 + ], + [ + 63, + -1, + 0, + 0, + -1, + -1, + -1, + 15, + -1, + 15, + -1, + -1, + 7, + 3, + -1, + -1, + -1, + 1, + -1, + -1, + 7, + -1, + 15, + -1, + -1, + 3, + 3, + -1, + -1, + 3, + -1, + 31, + -1, + -1, + 1, + -1, + 7, + -1, + -1, + -1, + 1, + 3, + -1, + 0, + 0, + -1, + 3, + 1, + -1, + 1, + -1, + 3, + -1, + -1, + -1, + 1, + -1, + 3, + -1, + -1, + 0, + -1, + -1, + 7, + 1, + -1, + 0 + ], + [ + 63, + -1, + 0, + 0, + -1, + -5, + 3, + 11, + -1, + 15, + 1, + 1, + -7, + -1, + -1, + 3, + 1, + -1, + 1, + -3, + 5, + -1, + -9, + 7, + -1, + 3, + 3, + -1, + 1, + -3, + -1, + -29, + 3, + -1, + 1, + -1, + -1, + 3, + -5, + 1, + -1, + 3, + -1, + 0, + 0, + -1, + 3, + 1, + -1, + -1, + 1, + -1, + -1, + 3, + -1, + 1, + 1, + 1, + 1, + -3, + 0, + -1, + 3, + -5, + -1, + 1, + 0 + ], + [ + 70, + 70, + 7, + 1, + 6, + 6, + 6, + 6, + -5, + -5, + 2, + 2, + 2, + 3, + 3, + 3, + -1, + -1, + 2, + 2, + 2, + -10, + -10, + -10, + -1, + -1, + 1, + 1, + -1, + -1, + -10, + -10, + -10, + -1, + -1, + -2, + -2, + -2, + -2, + 1, + 1, + 2, + 2, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 0, + 0, + -2, + -2, + -2, + -2, + 0, + -1, + -1, + -1, + -1, + -1, + 0 + ], + [ + 84, + 84, + 3, + 0, + 4, + 4, + 4, + 4, + -6, + -6, + 0, + 0, + 0, + -2, + -2, + -2, + 0, + 0, + 0, + 0, + 0, + 20, + 20, + 20, + 2, + 2, + 3, + 3, + -1, + -1, + 4, + 4, + 4, + 1, + 1, + 4, + 4, + 4, + 4, + 1, + 1, + 4, + 4, + -1, + 1, + -1, + -1, + -1, + -1, + 0, + 0, + 4, + 4, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -2, + -2, + -2, + 0, + 0, + 0 + ], + [ + 105, + 105, + -3, + 0, + 5, + 5, + 5, + 5, + 15, + 15, + -5, + -5, + -5, + -1, + -1, + -1, + 1, + 1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -3, + -3, + 1, + 1, + -35, + -35, + -35, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 5, + 5, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 1, + 1, + 1, + -1, + -1, + 0 + ], + [ + 105, + 105, + 6, + 0, + 9, + 9, + 9, + 9, + 0, + 0, + -3, + -3, + -3, + 0, + 0, + 0, + 0, + 0, + -3, + -3, + -3, + -7, + -7, + -7, + -4, + -4, + 3, + 3, + -1, + -1, + 25, + 25, + 25, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + -3, + 2, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + -3, + -3, + -3, + -1, + -1, + 1, + 1, + 1, + 1, + 0, + 4, + 4, + 4, + 0, + 0, + 0 + ], + [ + 105, + 105, + 6, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + -1, + -1, + -1, + 0, + 0, + 0, + 2, + 2, + 3, + 3, + 3, + 17, + 17, + 17, + 2, + 2, + 3, + 3, + -1, + -1, + 5, + 5, + 5, + -1, + -1, + -7, + -7, + -7, + -7, + -1, + -1, + -3, + -3, + 2, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 120, + 120, + -6, + 0, + 8, + 8, + 8, + 8, + 15, + 15, + 4, + 4, + 4, + -1, + -1, + -1, + 1, + 1, + -4, + -4, + -4, + -8, + -8, + -8, + 1, + 1, + 0, + 0, + -2, + -2, + 40, + 40, + 40, + -2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + -1, + -1, + 1 + ], + [ + 168, + 168, + 6, + 0, + 8, + 8, + 8, + 8, + 6, + 6, + 0, + 0, + 0, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 8, + 8, + 8, + 2, + 2, + -3, + -3, + -1, + -1, + 40, + 40, + 40, + 1, + 1, + 8, + 8, + 8, + 8, + -1, + -1, + 0, + 0, + 2, + 0, + -2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -2, + -2, + -2, + 0, + 0, + 0 + ], + [ + 189, + 189, + 0, + 0, + 1, + 1, + 1, + 1, + 9, + 9, + -1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + -5, + -5, + -5, + 21, + 21, + 21, + 3, + 3, + 0, + 0, + 0, + 0, + -39, + -39, + -39, + 0, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + -3, + -3, + 0, + 0, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + -1, + 3, + 3, + 3, + 1, + 1, + 0 + ], + [ + 189, + 189, + 0, + 0, + 13, + 13, + 13, + 13, + 9, + 9, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + -3, + -3, + -3, + -3, + 0, + 0, + 0, + 0, + -51, + -51, + -51, + 0, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + -3, + -3, + 0, + 0, + -1, + -1, + -1, + -1, + 1, + 1, + -3, + -3, + -3, + 1, + 1, + 1, + 1, + 1, + 1, + -1, + -3, + -3, + -3, + 1, + 1, + 0 + ], + [ + 189, + 189, + 0, + 0, + -11, + -11, + -11, + -11, + 9, + 9, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + -3, + -3, + -3, + -3, + -3, + 0, + 0, + 0, + 0, + 21, + 21, + 21, + 0, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + 9, + 9, + 0, + 0, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + -1, + -1, + 1, + 1, + 1, + 1, + -1, + -3, + -3, + -3, + 1, + 1, + 0 + ], + [ + 210, + 210, + 3, + 0, + 2, + 2, + 2, + 2, + 15, + 15, + 2, + 2, + 2, + -1, + -1, + -1, + -1, + -1, + 2, + 2, + 2, + 2, + 2, + 2, + -1, + -1, + 0, + 0, + 2, + 2, + 50, + 50, + 50, + 2, + 2, + -6, + -6, + -6, + -6, + 0, + 0, + -2, + -2, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -2, + -2, + 0, + 0, + -2, + -2, + -2, + -2, + 0, + -1, + -1, + -1, + -1, + -1, + 0 + ], + [ + 210, + 210, + -6, + 0, + 10, + 10, + 10, + 10, + -15, + -15, + -2, + -2, + -2, + 1, + 1, + 1, + 1, + 1, + -2, + -2, + -2, + -14, + -14, + -14, + 1, + 1, + 3, + 3, + 1, + 1, + 10, + 10, + 10, + 1, + 1, + 2, + 2, + 2, + 2, + -1, + -1, + 6, + 6, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -2, + -2, + 0, + 0, + -2, + -2, + -2, + -2, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ], + [ + 216, + 216, + 0, + 0, + 8, + 8, + 8, + 8, + -9, + -9, + 4, + 4, + 4, + -1, + -1, + -1, + 1, + 1, + -4, + -4, + -4, + 24, + 24, + 24, + -3, + -3, + 0, + 0, + 0, + 0, + -24, + -24, + -24, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -3, + -3, + -3, + -1, + -1, + -1 + ], + [ + 280, + 280, + -8, + 1, + 8, + 8, + 8, + 8, + -5, + -5, + -4, + -4, + -4, + -1, + -1, + -1, + -1, + -1, + 4, + 4, + 4, + 24, + 24, + 24, + -3, + -3, + -2, + -2, + 0, + 0, + 40, + 40, + 40, + -2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 1, + 0 + ], + [ + 280, + 280, + 10, + 1, + -8, + -8, + -8, + -8, + 10, + 10, + 0, + 0, + 0, + -2, + -2, + -2, + 0, + 0, + 0, + 0, + 0, + -8, + -8, + -8, + -2, + -2, + 1, + 1, + 1, + 1, + -40, + -40, + -40, + -1, + -1, + 8, + 8, + 8, + 8, + -1, + -1, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 315, + -5, + 0, + 0, + -5, + -5, + 11, + 11, + -2, + 30, + 3, + -1, + -9, + 2, + -2, + 2, + 0, + 0, + 3, + -1, + -9, + -5, + 27, + 11, + -2, + 6, + -3, + 1, + -1, + 3, + -5, + -85, + 11, + 1, + -1, + 3, + -5, + 3, + -13, + -1, + 1, + 3, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 3, + -1, + -1, + 1, + -1, + 3, + -1, + -1, + -1, + 0, + -2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 315, + -5, + 0, + 0, + -5, + 7, + -1, + 23, + -2, + 30, + -3, + 1, + 9, + 2, + -2, + 2, + 0, + 0, + -3, + 5, + -3, + -5, + 3, + 19, + -2, + 6, + -3, + 1, + 1, + -3, + -5, + 95, + -1, + 1, + -1, + -5, + 11, + -1, + 7, + 1, + -1, + 3, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + -1, + -1, + 3, + 1, + -1, + 1, + 1, + -3, + 1, + 0, + -2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 315, + 315, + -9, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + 3, + 3, + 3, + 0, + 0, + 0, + 0, + 0, + 3, + 3, + 3, + -21, + -21, + -21, + 0, + 0, + 0, + 0, + 0, + 0, + -45, + -45, + -45, + 0, + 0, + 3, + 3, + 3, + 3, + 0, + 0, + -5, + -5, + 3, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + 3, + 3, + 3, + -1, + -1, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 315, + -5, + 0, + 0, + -5, + -1, + 7, + 15, + 1, + -15, + 1, + -3, + 5, + -3, + 1, + 1, + 1, + -1, + 1, + 1, + -7, + -5, + 51, + 3, + 1, + -3, + 6, + -2, + 0, + 0, + -5, + -25, + 7, + -2, + 2, + 3, + 3, + -1, + -9, + 0, + 0, + 3, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 7, + -1, + -5, + 1, + -1, + 1, + 1, + -3, + 1, + 0, + 1, + 1, + -7, + -1, + 1, + 0 + ], + [ + 315, + -5, + 0, + 0, + -5, + 3, + 3, + 19, + 1, + -15, + -1, + 3, + -5, + 1, + 1, + -3, + -1, + 1, + -1, + 3, + -5, + -5, + -21, + 27, + 1, + -3, + 6, + -2, + 0, + 0, + -5, + 35, + 3, + -2, + 2, + -5, + 3, + 3, + 3, + 0, + 0, + 3, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + -5, + -1, + 7, + 1, + -1, + 3, + -1, + -1, + -1, + 0, + 1, + -3, + 5, + 1, + -1, + 0 + ], + [ + 336, + 336, + -6, + 0, + -16, + -16, + -16, + -16, + 6, + 6, + 0, + 0, + 0, + 2, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 16, + 16, + 16, + -2, + -2, + 0, + 0, + -2, + -2, + -16, + -16, + -16, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 1, + 1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 378, + 378, + 0, + 0, + 2, + 2, + 2, + 2, + -9, + -9, + 2, + 2, + 2, + -1, + -1, + -1, + -1, + -1, + 2, + 2, + 2, + -6, + -6, + -6, + 3, + 3, + 0, + 0, + 0, + 0, + -30, + -30, + -30, + 0, + 0, + -6, + -6, + -6, + -6, + 0, + 0, + 6, + 6, + 0, + 0, + -2, + -2, + 0, + 0, + 0, + 0, + -2, + -2, + -2, + 0, + 0, + 2, + 2, + 2, + 2, + 1, + 3, + 3, + 3, + -1, + -1, + 0 + ], + [ + 378, + -6, + 0, + 0, + -2, + 2, + -6, + 34, + -3, + 45, + 2, + 2, + -14, + 1, + 1, + -3, + -1, + 1, + -2, + 2, + 2, + 2, + -6, + -6, + -1, + 3, + 0, + 0, + 0, + 0, + 6, + -126, + 2, + 0, + 0, + 2, + -6, + -2, + 6, + 0, + 0, + 6, + -2, + 0, + 0, + -1, + 3, + -1, + 1, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + -2, + 2, + -2, + 2, + 0, + 3, + -1, + -9, + -1, + 1, + 0 + ], + [ + 378, + -6, + 0, + 0, + -2, + -14, + 10, + 18, + -3, + 45, + -2, + -2, + 14, + -3, + 1, + 1, + 1, + -1, + 2, + -2, + -2, + 2, + -6, + -6, + -1, + 3, + 0, + 0, + 0, + 0, + 6, + 114, + -14, + 0, + 0, + 2, + -6, + -2, + 6, + 0, + 0, + 6, + -2, + 0, + 0, + -1, + 3, + -1, + 1, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + 2, + -2, + 2, + -2, + 0, + 3, + -5, + 3, + 1, + -1, + 0 + ], + [ + 405, + 405, + 0, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + -3, + -3, + -3, + 0, + 0, + 0, + 0, + 0, + -3, + -3, + -3, + -27, + -27, + -27, + 0, + 0, + 0, + 0, + 0, + 0, + 45, + 45, + 45, + 0, + 0, + -3, + -3, + -3, + -3, + 0, + 0, + -3, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 5, + 5, + 5, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1 + ], + [ + 420, + 420, + -3, + 0, + -12, + -12, + -12, + -12, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 4, + 4, + 4, + 3, + 3, + 1, + 1, + 20, + 20, + 20, + -1, + -1, + 4, + 4, + 4, + 4, + 1, + 1, + -4, + -4, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -4, + -4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -4, + -4, + 0, + 0, + 0 + ], + [ + 512, + 512, + 8, + -1, + 0, + 0, + 0, + 0, + -16, + -16, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + -4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 1 + ], + [ + 567, + -9, + 0, + 0, + -9, + -1, + 15, + 15, + 0, + 0, + 3, + -5, + 3, + 0, + 0, + 0, + 0, + 0, + 3, + -5, + 3, + -9, + -9, + 39, + 0, + 0, + 0, + 0, + 0, + 0, + -9, + -81, + 15, + 0, + 0, + -1, + -9, + 7, + -9, + 0, + 0, + 3, + -1, + 0, + 0, + 1, + -3, + -1, + 1, + 1, + -1, + -5, + -1, + 7, + -1, + 1, + -1, + 3, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 567, + -9, + 0, + 0, + -9, + 11, + 3, + 27, + 0, + 0, + -3, + 5, + -3, + 0, + 0, + 0, + 0, + 0, + -3, + 1, + 9, + -9, + 63, + 15, + 0, + 0, + 0, + 0, + 0, + 0, + -9, + 99, + 3, + 0, + 0, + -1, + 15, + -5, + 3, + 0, + 0, + 3, + -1, + 0, + 0, + 1, + -3, + -1, + 1, + -1, + 1, + 7, + -1, + -5, + -1, + 1, + 1, + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 630, + -10, + 0, + 0, + 2, + -2, + -10, + 30, + -1, + 15, + -2, + 2, + 2, + 3, + -1, + -1, + 1, + -1, + 2, + 2, + -14, + -2, + 54, + -10, + 1, + -3, + 3, + -1, + -1, + 3, + 10, + -130, + -2, + 1, + -1, + -2, + -10, + 2, + 10, + 1, + -1, + -6, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 2, + 0, + 0, + -2, + 2, + 2, + -2, + 0, + 1, + 1, + -7, + 1, + -1, + 0 + ], + [ + 630, + -10, + 0, + 0, + 2, + -2, + -10, + 30, + -1, + 15, + -2, + 2, + 2, + 3, + -1, + -1, + 1, + -1, + 2, + -6, + 10, + -2, + -42, + 22, + 1, + -3, + 3, + -1, + 1, + -3, + 10, + -130, + -2, + 1, + -1, + 6, + -2, + -6, + 2, + -1, + 1, + -6, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 2, + 0, + 0, + 2, + -2, + -2, + 2, + 0, + 1, + 1, + -7, + 1, + -1, + 0 + ], + [ + 630, + -10, + 0, + 0, + -10, + 14, + 14, + -18, + -1, + 15, + 2, + -2, + -2, + 3, + -1, + -1, + -1, + 1, + 2, + -2, + -2, + -10, + 54, + 22, + -1, + 3, + 3, + -1, + 1, + -3, + -10, + -50, + 14, + -1, + 1, + 6, + -10, + -2, + -2, + 1, + -1, + -6, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + 2, + -6, + 0, + 0, + -2, + -2, + 2, + 2, + 0, + -1, + -1, + 7, + 1, + -1, + 0 + ], + [ + 630, + -10, + 0, + 0, + 2, + -18, + 6, + 14, + -1, + 15, + 2, + -2, + -2, + -1, + -1, + 3, + -1, + 1, + -2, + -2, + 14, + -2, + 54, + -10, + 1, + -3, + 3, + -1, + -1, + 3, + 10, + 110, + -18, + 1, + -1, + -2, + -10, + 2, + 10, + 1, + -1, + -6, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 2, + 0, + 0, + 2, + -2, + -2, + 2, + 0, + 1, + -3, + 5, + -1, + 1, + 0 + ], + [ + 630, + -10, + 0, + 0, + 2, + -18, + 6, + 14, + -1, + 15, + 2, + -2, + -2, + -1, + -1, + 3, + -1, + 1, + -2, + 6, + -10, + -2, + -42, + 22, + 1, + -3, + 3, + -1, + 1, + -3, + 10, + 110, + -18, + 1, + -1, + 6, + -2, + -6, + 2, + -1, + 1, + -6, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 2, + 0, + 0, + -2, + 2, + 2, + -2, + 0, + 1, + -3, + 5, + -1, + 1, + 0 + ], + [ + 630, + -10, + 0, + 0, + -10, + 22, + 6, + -10, + -1, + 15, + -2, + 2, + 2, + -1, + -1, + 3, + 1, + -1, + -2, + 2, + 2, + -10, + 6, + 38, + -1, + 3, + 3, + -1, + -1, + 3, + -10, + 70, + 6, + -1, + 1, + -2, + -2, + -2, + 14, + -1, + 1, + -6, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -6, + 2, + 2, + 0, + 0, + -2, + -2, + 2, + 2, + 0, + -1, + 3, + -5, + -1, + 1, + 0 + ], + [ + 945, + -15, + 0, + 0, + 1, + 1, + -15, + 49, + -3, + 45, + 1, + -3, + 5, + 1, + 1, + -3, + 1, + -1, + 1, + -3, + 5, + 1, + 33, + -15, + 1, + -3, + 0, + 0, + 0, + 0, + -15, + 225, + 1, + 0, + 0, + 1, + 9, + 1, + -15, + 0, + 0, + -3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + -3, + 1, + 1, + 1, + -1, + -3, + 1, + 1, + 1, + 0, + -3, + 1, + 9, + -1, + 1, + 0 + ], + [ + 945, + -15, + 0, + 0, + 1, + -7, + 9, + -23, + -3, + 45, + 1, + 1, + -7, + 1, + 1, + -3, + 1, + -1, + 1, + 1, + -7, + 1, + 33, + -15, + 1, + -3, + 0, + 0, + 0, + 0, + -15, + -135, + 25, + 0, + 0, + 1, + 9, + -7, + 9, + 0, + 0, + 9, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 1, + -3, + 5, + -1, + 1, + 1, + -3, + 1, + 1, + 0, + -3, + 1, + 9, + -1, + 1, + 0 + ], + [ + 945, + -15, + 0, + 0, + 1, + -27, + 13, + 21, + -3, + 45, + -1, + 3, + -5, + -3, + 1, + 1, + -1, + 1, + -1, + -1, + 7, + 1, + -39, + 9, + 1, + -3, + 0, + 0, + 0, + 0, + -15, + -195, + 29, + 0, + 0, + -7, + 9, + 5, + -3, + 0, + 0, + -3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 1, + 1, + -3, + 1, + -1, + -1, + -1, + 3, + -1, + 0, + -3, + 5, + -3, + 1, + -1, + 0 + ], + [ + 945, + -15, + 0, + 0, + 1, + 13, + -11, + -3, + -3, + 45, + -1, + -1, + 7, + -3, + 1, + 1, + -1, + 1, + -1, + 3, + -5, + 1, + -39, + 9, + 1, + -3, + 0, + 0, + 0, + 0, + -15, + 165, + 5, + 0, + 0, + 1, + -15, + 5, + -3, + 0, + 0, + 9, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 5, + -3, + 1, + -1, + 1, + -1, + -1, + -1, + 3, + 0, + -3, + 5, + -3, + 1, + -1, + 0 + ], + [ + 1008, + -16, + 0, + 0, + -16, + 16, + 16, + 16, + 2, + -30, + 0, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + 0, + 0, + 0, + -16, + 48, + 48, + 2, + -6, + -6, + 2, + 0, + 0, + -16, + 16, + 16, + 2, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 3, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + -2, + 0, + 0, + 0 + ], + [ + 1260, + -20, + 0, + 0, + 4, + 12, + -4, + -52, + -2, + 30, + 0, + 0, + 0, + 2, + -2, + 2, + 0, + 0, + 0, + 0, + 0, + -4, + 12, + 12, + 2, + -6, + 6, + -2, + 0, + 0, + 20, + -20, + -20, + 2, + -2, + -4, + 12, + 4, + -12, + 0, + 0, + 12, + -4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -4, + 4, + -4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 2, + -2, + -2, + 0, + 0, + 0 + ], + [ + 1512, + -24, + 0, + 0, + -8, + -8, + 24, + -8, + -3, + 45, + -4, + 4, + 4, + 1, + 1, + -3, + -1, + 1, + 4, + -4, + -4, + 8, + -24, + -24, + -1, + 3, + 0, + 0, + 0, + 0, + 24, + 216, + -40, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -3, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + -1, + -9, + -1, + 1, + 0 + ], + [ + 1512, + -24, + 0, + 0, + -8, + 24, + -8, + 24, + -3, + 45, + 4, + -4, + -4, + -3, + 1, + 1, + 1, + -1, + -4, + 4, + 4, + 8, + -24, + -24, + -1, + 3, + 0, + 0, + 0, + 0, + 24, + -264, + -8, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -3, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 3, + -5, + 3, + 1, + -1, + 0 + ], + [ + 1890, + -30, + 0, + 0, + -10, + 10, + 2, + 42, + 3, + -45, + 2, + -6, + 10, + 3, + -1, + -1, + -1, + 1, + -2, + 2, + 2, + 10, + -30, + -30, + 1, + -3, + 0, + 0, + 0, + 0, + 30, + -150, + -22, + 0, + 0, + 2, + -6, + -2, + 6, + 0, + 0, + 6, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + 2, + -2, + 2, + -2, + 0, + -3, + 5, + -3, + -1, + 1, + 0 + ], + [ + 1890, + -30, + 0, + 0, + 2, + -14, + 2, + 18, + 3, + -45, + -2, + 2, + 2, + 3, + -1, + -1, + 1, + -1, + -2, + 2, + 2, + 2, + -78, + 18, + -1, + 3, + 0, + 0, + 0, + 0, + -30, + -30, + 34, + 0, + 0, + -6, + -6, + 10, + -6, + 0, + 0, + 6, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 6, + -2, + -2, + 0, + 0, + -2, + -2, + 2, + 2, + 0, + 3, + -5, + 3, + -1, + 1, + 0 + ], + [ + 1890, + -30, + 0, + 0, + -10, + -6, + 18, + 26, + 3, + -45, + -2, + 6, + -10, + -1, + -1, + 3, + 1, + -1, + 2, + -2, + -2, + 10, + -30, + -30, + 1, + -3, + 0, + 0, + 0, + 0, + 30, + 90, + -38, + 0, + 0, + 2, + -6, + -2, + 6, + 0, + 0, + 6, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + -2, + 2, + -2, + 2, + 0, + -3, + 1, + 9, + 1, + -1, + 0 + ], + [ + 1890, + -30, + 0, + 0, + 2, + -6, + -6, + 26, + 3, + -45, + 2, + -2, + -2, + -1, + -1, + 3, + -1, + 1, + 2, + -2, + -2, + 2, + 66, + -30, + -1, + 3, + 0, + 0, + 0, + 0, + -30, + 90, + 26, + 0, + 0, + 2, + 18, + -6, + -6, + 0, + 0, + 6, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + -2, + 6, + 0, + 0, + -2, + -2, + 2, + 2, + 0, + 3, + -1, + -9, + 1, + -1, + 0 + ], + [ + 2268, + -36, + 0, + 0, + -12, + 28, + 12, + -36, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 12, + -36, + -36, + 0, + 0, + 0, + 0, + 0, + 0, + 36, + -36, + -36, + 0, + 0, + -4, + 12, + 4, + -12, + 0, + 0, + -12, + 4, + 0, + 0, + -1, + 3, + -1, + 1, + 0, + 0, + 4, + -4, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2520, + -40, + 0, + 0, + 8, + -24, + 8, + -24, + -1, + 15, + 4, + -4, + -4, + 3, + -1, + -1, + 1, + -1, + -4, + 4, + 4, + -8, + 24, + 24, + 1, + -3, + -6, + 2, + 0, + 0, + 40, + 200, + -56, + -2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -7, + 1, + -1, + 0 + ], + [ + 2520, + -40, + 0, + 0, + 8, + 8, + -24, + 8, + -1, + 15, + -4, + 4, + 4, + -1, + -1, + 3, + -1, + 1, + 4, + -4, + -4, + -8, + 24, + 24, + 1, + -3, + -6, + 2, + 0, + 0, + 40, + -280, + -24, + -2, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -3, + 5, + -1, + 1, + 0 + ], + [ + 2520, + -40, + 0, + 0, + 8, + -8, + -8, + -8, + 2, + -30, + 0, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + 0, + 0, + 0, + -8, + -72, + 56, + -2, + 6, + 3, + -1, + -1, + 3, + 40, + -40, + -40, + 1, + -1, + 8, + 8, + -8, + -8, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 2520, + -40, + 0, + 0, + 8, + -8, + -8, + -8, + 2, + -30, + 0, + 0, + 0, + -2, + 2, + -2, + 0, + 0, + 0, + 0, + 0, + -8, + 120, + -8, + -2, + 6, + 3, + -1, + 1, + -3, + 40, + -40, + -40, + 1, + -1, + -8, + -8, + 8, + 8, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 2, + 2, + 0, + 0, + 0 + ], + [ + 2835, + -45, + 0, + 0, + 3, + -25, + 15, + -9, + 0, + 0, + -3, + 1, + 9, + 0, + 0, + 0, + 0, + 0, + -3, + 5, + -3, + 3, + 27, + -21, + 0, + 0, + 0, + 0, + 0, + 0, + -45, + -225, + 63, + 0, + 0, + 3, + 3, + -1, + -9, + 0, + 0, + -9, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + -5, + 3, + -1, + -1, + 1, + 1, + 1, + -3, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2835, + -45, + 0, + 0, + 3, + 11, + -21, + 27, + 0, + 0, + 3, + -1, + -9, + 0, + 0, + 0, + 0, + 0, + 3, + -1, + -9, + 3, + -45, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + -45, + 315, + 27, + 0, + 0, + -5, + 3, + 3, + 3, + 0, + 0, + -9, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + -1, + 3, + -5, + -1, + 1, + 3, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2835, + -45, + 0, + 0, + 3, + 15, + -9, + -33, + 0, + 0, + -3, + 5, + -3, + 0, + 0, + 0, + 0, + 0, + -3, + 1, + 9, + 3, + 27, + -21, + 0, + 0, + 0, + 0, + 0, + 0, + -45, + 135, + 39, + 0, + 0, + 11, + -21, + -1, + -9, + 0, + 0, + 3, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + -1, + -1, + 3, + 1, + -1, + 1, + 1, + 1, + -3, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 2835, + -45, + 0, + 0, + 3, + 3, + 3, + -45, + 0, + 0, + 3, + -5, + 3, + 0, + 0, + 0, + 0, + 0, + 3, + -5, + 3, + 3, + -45, + 3, + 0, + 0, + 0, + 0, + 0, + 0, + -45, + -45, + 51, + 0, + 0, + -5, + 3, + -5, + 27, + 0, + 0, + 3, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 3, + -1, + -1, + 1, + -1, + -1, + 3, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] +} diff --git a/research/clifford-quadratic-orbit-blocks/source/width-nine-input.json b/research/clifford-quadratic-orbit-blocks/source/width-nine-input.json new file mode 100644 index 0000000000..77a5c8b23b --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/source/width-nine-input.json @@ -0,0 +1,494 @@ +{ + "status": "PASS_THREE_QUBIT_CLIFFORD_THRESHOLD_TEN", + "source_pins": 4, + "projective_order": 92897280, + "symplectic_order": 1451520, + "quotient_source_rows": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 29, + 32, + 33, + 36, + 37, + 38 + ], + "quotient_source_classes": [ + [ + 1, + 2 + ], + [ + 3 + ], + [ + 4 + ], + [ + 5, + 6, + 7, + 8 + ], + [ + 9, + 10 + ], + [ + 11, + 12, + 13 + ], + [ + 14, + 15, + 16 + ], + [ + 17, + 18 + ], + [ + 19, + 20, + 21 + ], + [ + 22, + 23, + 24 + ], + [ + 25, + 26 + ], + [ + 27, + 28 + ], + [ + 29, + 30 + ], + [ + 31, + 32, + 33 + ], + [ + 34, + 35 + ], + [ + 36, + 37, + 38, + 39 + ], + [ + 40, + 41 + ], + [ + 42, + 43 + ], + [ + 44 + ], + [ + 45 + ], + [ + 46, + 47 + ], + [ + 48, + 49 + ], + [ + 50, + 51 + ], + [ + 52, + 53, + 54 + ], + [ + 55, + 56 + ], + [ + 57, + 58, + 59, + 60 + ], + [ + 61 + ], + [ + 62, + 63, + 64 + ], + [ + 65, + 66 + ], + [ + 67 + ] + ], + "quotient_class_sizes": [ + 1, + 2240, + 161280, + 945, + 672, + 7560, + 30240, + 60480, + 7560, + 315, + 10080, + 13440, + 40320, + 63, + 40320, + 3780, + 120960, + 3780, + 20160, + 120960, + 48384, + 145152, + 90720, + 11340, + 90720, + 45360, + 96768, + 10080, + 60480, + 207360 + ], + "fixed_dimensions": [ + 6, + 0, + 0, + 4, + 4, + 3, + 2, + 1, + 3, + 4, + 2, + 2, + 2, + 5, + 1, + 3, + 1, + 2, + 0, + 0, + 2, + 1, + 1, + 2, + 1, + 2, + 0, + 3, + 1, + 0 + ], + "transvection_column_one_based": 14, + "odd_tensor_multiplicities": { + "1": [ + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "3": [ + 0, + 1, + 1, + 2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "5": [ + 0, + 5, + 5, + 10, + 0, + 0, + 0, + 0, + 4, + 0, + 1, + 5, + 0, + 0, + 0, + 0, + 5, + 6, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "7": [ + 30, + 0, + 1, + 0, + 28, + 104, + 105, + 0, + 0, + 0, + 35, + 0, + 70, + 35, + 120, + 126, + 7, + 0, + 42, + 140, + 35, + 20, + 140, + 0, + 0, + 28, + 21, + 90, + 70, + 64 + ], + "9": [ + 269, + 0, + 85, + 35, + 840, + 1890, + 1975, + 175, + 28, + 350, + 1407, + 210, + 2625, + 1575, + 3900, + 4410, + 945, + 567, + 2835, + 5250, + 2625, + 1728, + 5600, + 1400, + 1575, + 2940, + 2835, + 6075, + 5250, + 5440 + ], + "11": [ + 155, + 17204, + 23001, + 40953, + 5236, + 6138, + 11935, + 32725, + 86020, + 65450, + 60775, + 140250, + 45815, + 71995, + 41140, + 75922, + 207009, + 227205, + 106029, + 91630, + 137445, + 201960, + 157080, + 261800, + 294525, + 267036, + 318087, + 227205, + 274890, + 371008 + ], + "13": [ + 18383, + 632060, + 1008865, + 1640925, + 620620, + 721370, + 1098175, + 1884025, + 3918772, + 3768050, + 3861143, + 6782490, + 3878875, + 4765475, + 3989700, + 6250530, + 10927345, + 11530233, + 7912905, + 7757750, + 9420125, + 11454872, + 11525800, + 15072200, + 16956225, + 16579420, + 19217055, + 16956225, + 18840250, + 24115520 + ] + }, + "odd_tensor_ranks": { + "1": 64, + "3": 45760, + "5": 8961920, + "7": 77913472, + "9": 92894144, + "11": 92897280, + "13": 92897280 + }, + "width_nine_nullity": 3136, + "sharp_threshold": 10, + "quadratic_orbit_sizes": [ + 36, + 28 + ], + "transvection_fixtures": 63, + "remaining_degree_fractions": [ + "17/108", + "1/12" + ], + "uniform_spectral_bounds_from_ten": [ + "945/262144", + "762615/32768" + ], + "uniform_condition_upper_bound": 6456, + "negative_controls": [ + "changed table cell", + "wrong adjoint identification", + "discarded native fourth-power sign", + "omitted Pauli average", + "false width-nine independence", + "overfunded transvection trace", + "omitted odd-Arf orbit", + "even width through odd-sector formula" + ], + "scope": "Exact arithmetic supporting PROOF.md; the published character identification is a cited input, not reconstructed." +} diff --git a/research/clifford-quadratic-orbit-blocks/verify.py b/research/clifford-quadratic-orbit-blocks/verify.py new file mode 100644 index 0000000000..596d50c538 --- /dev/null +++ b/research/clifford-quadratic-orbit-blocks/verify.py @@ -0,0 +1,510 @@ +"""Exact new Bell-congruence/orbit corroboration for two actual even blocks. + +The five retained source objects are inert premises. No predecessor engine, +group enumeration, width-nine decomposition, order-three or LP replay is run. +""" +from fractions import Fraction +import hashlib +import json +from pathlib import Path +import sys + +P = Path(__file__).resolve().parent +SOURCE_SHA = '51d69b9daeefb8ac8b9c530605e17dad60e35e426d31652928b1dff29582fd81' +SOURCE_PATHS = {'predecessor/PR6714-PROOF.md', 'predecessor/PR6794-PROOF.md', + 'source/table.json', 'source/width-nine-input.json', 'source/EXTERNAL.json'} +UNITS = ((1, 0), (0, 1), (-1, 0), (0, -1)) +ZERO = (0, 0) +ONE = (1, 0) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def unique(pairs): + result = {} + for key, value in pairs: + need(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 = (P / 'SOURCE-PINS.json').read_bytes() + need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA, 'source manifest bytes') + manifest = load(raw) + need(type(manifest['schema_version']) is int and manifest['schema_version'] == 1, + 'source manifest schema') + files = manifest['files'] + need(len(files) == 5 and {r['local_path'] for r in files} == SOURCE_PATHS, + 'source inventory') + result = {} + for row in files: + path = P / row['local_path'] + need(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() + need((len(data), hashlib.sha256(data).hexdigest(), blob, row['mode']) == + (row['bytes'], row['sha256'], row['git_blob'], '100644'), 'source bytes') + result[row['local_path']] = row['sha256'] + return result + + +def cadd(left, right): + return left[0]+right[0], left[1]+right[1] + + +def cmul(left, right): + return left[0]*right[0]-left[1]*right[1], left[0]*right[1]+left[1]*right[0] + + +def conjugate(value): + return value[0], -value[1] + + +def blank(): + return [[ZERO for _ in range(8)] for _ in range(8)] + + +def identity(): + result = blank() + for i in range(8): + result[i][i] = ONE + return result + + +def frozen(matrix): + return tuple(tuple(row) for row in matrix) + + +def scale(matrix, scalar): + return [[cmul(value, scalar) for value in row] for row in matrix] + + +def transpose(matrix): + return [list(row) for row in zip(*matrix)] + + +def bar(matrix): + return [[conjugate(value) for value in row] for row in matrix] + + +def adjoint(matrix): + return transpose(bar(matrix)) + + +def multiply(left, right): + result = blank() + for i in range(8): + for k, value in enumerate(left[i]): + if value != ZERO: + for j, other in enumerate(right[k]): + if other != ZERO: + result[i][j] = cadd(result[i][j], cmul(value, other)) + return result + + +def difference(left, right): + for i in range(8): + for j in range(8): + if left[i][j] != right[i][j]: + return dict(row=i, column=j, left=left[i][j], right=right[i][j]) + return None + + +def parity(value): + return value.bit_count() % 2 + + +def omega(left, right): + return parity((left & 7) & (right >> 3)) ^ parity((left >> 3) & (right & 7)) + + +def quadratic(form, vector): + return parity((vector & 7) & (vector >> 3)) ^ omega(vector, form) + + +def arf(form): + return parity((form & 7) & (form >> 3)) + + +def pauli(label, phase_override=None): + a, b = label & 7, label >> 3 + phase = parity(a & b) if phase_override is None else phase_override + result = blank() + for x in range(8): + result[x ^ a][x] = UNITS[(phase+2*parity(b & x)) % 4] + return result + + +def generators(): + result = [] + for j in range(3): + x, z = pauli(1 << j), pauli(8 << j) + s = blank() + rx = scale(identity(), (1, 1)) + for column in range(8): + s[column][column] = UNITS[(column >> j) & 1] + rx[column ^ (1 << j)][column] = (1, -1) + result.extend([(f'X{j}', x, 1), (f'Z{j}', z, 1), + (f'S{j}', s, 1), (f'Rx{j}', rx, 2)]) + for control in range(3): + for target in range(3): + if control != target: + matrix = blank() + for column in range(8): + row = column ^ ((1 << target) if (column >> control) & 1 else 0) + matrix[row][column] = ONE + result.append((f'CNOT{control}{target}', matrix, 1)) + result.append(('central_i', scale(identity(), (0, 1)), 1)) + need(len(result) == 19 and len({name for name, _, _ in result}) == 19, + 'generator inventory') + for name, matrix, denominator in result: + target = scale(identity(), (denominator*denominator, 0)) + need(multiply(matrix, adjoint(matrix)) == target == multiply(adjoint(matrix), matrix), + 'actual Gaussian-dyadic unitarity: '+name) + return result + + +def transpose_guard(matrix, assigned_arf): + need(transpose(matrix) == scale(matrix, UNITS[2*assigned_arf]), + 'transpose/Arf assignment') + + +def basis_checks(bells): + characters, gram_digest, weight_digest = [], hashlib.sha256(), hashlib.sha256() + for w, basis in enumerate(bells): + transpose_guard(basis, arf(w)) + need(adjoint(basis) == basis and multiply(basis, basis) == identity(), 'Hermitian Bell basis') + character = [quadratic(w, v) for v in range(64)] + characters.append(character) + for v, other in enumerate(bells): + value = ZERO + for i in range(8): + for j in range(8): + value = cadd(value, cmul(conjugate(basis[i][j]), other[i][j])) + need(value == ((8, 0) if v == w else ZERO), 'complete Bell orthogonality') + gram_digest.update(canonical([w, v, value])+b'\n') + actual = multiply(multiply(other, basis), transpose(other)) + need(actual == scale(basis, UNITS[2*character[v]]), 'actual Pauli weight line') + weight_digest.update(canonical([w, v, character[v], actual])+b'\n') + need(len({tuple(c) for c in characters}) == 64, 'distinct quadratic weight characters') + orbits = [[w for w in range(64) if arf(w) == a] for a in (0, 1)] + need([len(o) for o in orbits] == [36, 28], 'transpose orbit dimensions') + return orbits, dict(distinct_form_vector_pairs=4096, literal_weight_line_cases=4096, + distinct_Bell_inner_products=4096, orthogonality_sha256=gram_digest.hexdigest(), + weight_line_sha256=weight_digest.hexdigest()) + + +def binary_rank(vectors): + pivots = {} + for value in vectors: + while value: + bit = value.bit_length()-1 + if bit in pivots: + value ^= pivots[bit] + else: + pivots[bit] = value + break + return len(pivots) + + +def matrix_trace(matrix): + result = ZERO + for i in range(8): + result = cadd(result, matrix[i][i]) + return result + + +def square_traces(matrix, denominator, permutation, phases): + natural_trace = matrix_trace(matrix) + squared_trace = matrix_trace(multiply(matrix, matrix)) + tensor_trace = cmul(natural_trace, natural_trace) + divisor = 2*denominator*denominator + result = [] + for assigned_arf in (0, 1): + sign = 1 if assigned_arf == 0 else -1 + numerator = cadd(tensor_trace, (sign*squared_trace[0], sign*squared_trace[1])) + need(all(x % divisor == 0 for x in numerator), 'exact square-character denominator') + expected = numerator[0]//divisor, numerator[1]//divisor + actual = ZERO + for w, target in enumerate(permutation): + if target == w and arf(w) == assigned_arf: + actual = cadd(actual, UNITS[phases[w]]) + need(actual == expected, 'literal Sym2/Lambda2 character identity') + result.append(actual) + return result + + +def signed_action(matrix, denominator, bells, lookup): + labels, signs = [], [] + for basis in bells: + actual = multiply(multiply(matrix, basis), adjoint(matrix)) + need(all(x % (denominator*denominator) == 0 for row in actual for pair in row for x in pair), + 'signed Pauli exact denominator') + normalized = [[(a//(denominator*denominator), b//(denominator*denominator)) + for a, b in row] for row in actual] + need(frozen(normalized) in lookup, 'actual Pauli normalization') + label, phase = lookup[frozen(normalized)] + need(phase in (0, 2), 'Hermitian Pauli sign') + labels.append(label) + signs.append(1 if phase == 0 else -1) + need(sorted(labels) == list(range(64)) and labels[0] == 0, 'Pauli label permutation') + for u in range(64): + for v in range(64): + need(labels[u ^ v] == (labels[u] ^ labels[v]), 'symplectic map linearity') + need(omega(labels[u], labels[v]) == omega(u, v), 'symplectic map pairing') + return labels, signs + + +def congruence_action(matrix, denominator, bells, lookup): + labels, phases = [], [] + for w, basis in enumerate(bells): + actual = multiply(multiply(matrix, basis), transpose(matrix)) + divisor = denominator*denominator + need(all(x % divisor == 0 for row in actual for pair in row for x in pair), + 'Bell congruence exact denominator') + normalized = [[(a//divisor, b//divisor) for a, b in row] for row in actual] + need(frozen(normalized) in lookup, 'Gaussian-unit Bell congruence') + target, phase = lookup[frozen(normalized)] + need(arf(w) == arf(target), 'congruence transpose orbit') + labels.append(target) + phases.append(phase) + need(sorted(labels) == list(range(64)), 'Bell congruence permutation') + return labels, phases + + +def generator_actions(items, bells): + lookup = {} + for label, basis in enumerate(bells): + for phase, unit in enumerate(UNITS): + key = frozen(scale(basis, unit)) + need(key not in lookup, 'distinct phased Bell basis') + lookup[key] = label, phase + result, intertwiner_digest = [], hashlib.sha256() + for name, matrix, denominator in items: + tau, signs = signed_action(matrix, denominator, bells, lookup) + perm, phases = congruence_action(matrix, denominator, bells, lookup) + traces = square_traces(matrix, denominator, perm, phases) + for w, target in enumerate(perm): + for v in range(64): + need(quadratic(target, tau[v]) == quadratic(w, v), 'quadratic pullback permutation') + left = scale(multiply(bar(matrix), adjoint(bells[w])), UNITS[phases[w]]) + right = multiply(adjoint(bells[target]), matrix) + need(left == right, 'whole Vbar/Bell intertwiner') + intertwiner_digest.update(canonical([name, w, target, phases[w], left])+b'\n') + result.append(dict(name=name, denominator=denominator, numerator_sha256=digest(matrix), + Pauli_labels=tau, Pauli_signs=signs, Bell_labels=perm, + Bell_phase_exponents=phases, Sym2_Lambda2_traces=traces)) + return result, dict(generators=19, signed_Pauli_conjugations=19*64, + Bell_congruences=19*64, whole_matrix_intertwiners=19*64, + quadratic_transport_cases=19*64*64, + symplectic_linearity_pairs=19*64*64, symplectic_pairing_pairs=19*64*64, + distinct_square_character_checks=19*2, + intertwiner_sha256=intertwiner_digest.hexdigest()) + + +def ordered_pair_orbits(orbits, actions): + result = [] + for labels in orbits: + seen, queue = {(labels[0], labels[1])}, [(labels[0], labels[1])] + cursor = 0 + while cursor < len(queue): + left, right = queue[cursor] + cursor += 1 + for action in actions: + perm = action['Bell_labels'] + pair = perm[left], perm[right] + if pair not in seen: + seen.add(pair) + queue.append(pair) + complete = {(left, right) for left in labels for right in labels if left != right} + need(seen == complete, 'ordered-pair two-transitivity') + result.append(dict(Arf=arf(labels[0]), dimension=len(labels), + ordered_distinct_pairs_reached=len(seen), + directed_generator_edges_checked=19*len(seen), + sorted_pair_sha256=digest(sorted(seen)))) + return result + + +def transvection_data(actions, orbits): + action = next(a for a in actions if a['name'] == 'S0') + tau, perm = action['Pauli_labels'], action['Bell_labels'] + need(all(tau[tau[v]] == v for v in range(64)), 'S0 quotient involution') + need(sum(tau[v] == v for v in range(64)) == 32, 'S0 fixed-vector count') + need(binary_rank([tau[1 << j] ^ (1 << j) for j in range(6)]) == 1, + 'S0 quotient transvection rank') + fixed = [[w for w in orbit if perm[w] == w] for orbit in orbits] + need([len(row) for row in fixed] == [16, 16], 'S0 fixed quadratic forms') + return dict(generator='S0', fixed_Pauli_labels=32, quotient_rank_difference=1, + fixed_forms_by_Arf=fixed, fixed_form_counts=[16, 16], + actual_Sym2_Lambda2_traces=action['Sym2_Lambda2_traces'], + nontrivial_permutation_character_values=[15, 15]) + + +def row_guard(table, published_row, degree, transvection_value): + row = table[published_row-1] + need(row[0] == degree and all(row[c-1] == transvection_value for c in (31, 32, 33)), + 'source constituent degree/transvection identification') + + +def source_blocks(transvection): + table = load((P / 'source/table.json').read_bytes()) + data = load((P / 'source/width-nine-input.json').read_bytes()) + external = load((P / 'source/EXTERNAL.json').read_bytes()) + chars, rows = table['characters'], data['quotient_source_rows'] + need(len(chars) == 67 and all(len(row) == 67 for row in chars), 'published table shape') + need(all(type(v) is int for row in chars for v in row), 'published table integer entries') + need(len(rows) == len(set(rows)) == 30 and all(type(r) is int and 1 <= r <= 67 for r in rows), + 'source quotient row labels') + multiplicities = data['odd_tensor_multiplicities']['9'] + need(len(multiplicities) == 30 and all(type(m) is int and m >= 0 for m in multiplicities), + 'inherited width-nine multiplicity shape') + need(data['quotient_source_classes'][13] == [31, 32, 33] + and data['transvection_column_one_based'] == 14 + and data['quotient_class_sizes'][13] == 63 and data['fixed_dimensions'][13] == 5, + 'inherited transvection class binding') + need(table['order'] == data['projective_order'] == 92897280, 'projective Gram order') + need(external['table_sha256'] == hashlib.sha256((P/'source/table.json').read_bytes()).hexdigest(), + 'external table byte association') + for r in rows: + need(chars[r-1][30] == chars[r-1][31] == chars[r-1][32], 'quotient transvection fibre') + inherited = dict(zip(rows, multiplicities)) + trivial = [r for r in rows if chars[r-1][0] == 1] + need(trivial == [1] and inherited[1] == 269, 'inherited trivial width-nine row') + blocks = [] + for dimension, value in zip((36, 28), transvection['nontrivial_permutation_character_values']): + candidates = [r for r in rows if chars[r-1][0] == dimension-1 and chars[r-1][30] == value] + need(len(candidates) == 1, 'unique source constituent row') + r = candidates[0] + row_guard(chars, r, dimension-1, value) + multiplicity = inherited[1]+inherited[r] + gram = Fraction(92897280*multiplicity, (8**10)*dimension) + blocks.append(dict(actual_even_dimension=dimension, published_constituent_row=r, + quotient_constituent_degree=dimension-1, transvection_character=value, + inherited_m9_trivial=inherited[1], inherited_m9_constituent=inherited[r], + m_mu_at_width10=multiplicity, Gram_eigenvalue=[gram.numerator, gram.denominator], + regular_matrix_block_dimension=dimension*dimension)) + need([r['published_constituent_row'] for r in blocks] == [7, 6], 'published row convention') + return blocks, chars, inherited + + +def rejected(name, callback, reason, witness): + try: + callback() + except ValueError as error: + need(str(error) == reason, 'wrong rejection reason: '+name) + return dict(name=name, outcome='REJECTED_FOR_INTENDED_REASON', reason=reason, witness=witness) + raise ValueError('control accepted: '+name) + + +def matrix_guard(left, right, reason): + need(left == right, reason) + + +def convention_guard(label, matrix): + need(matrix == pauli(label), 'wrong binary-dot Bell phase') + + +def controls(items, bells, actions, chars, inherited): + central = next(a for a in actions if a['name'] == 'central_i') + g = next(g for name, g, _ in items if name == 'central_i') + phase = central['Bell_phase_exponents'][0] + need(phase == 2 and central['Bell_labels'][0] == 0, 'actual central congruence phase') + wrong = scale(multiply(g, adjoint(bells[0])), UNITS[phase]) + right = multiply(adjoint(bells[0]), g) + result = [rejected('V_in_place_of_Vbar', + lambda: matrix_guard(wrong, right, 'Vbar conjugation is necessary'), + 'Vbar conjugation is necessary', dict(generator='central_i', theta=UNITS[phase], + mismatch=difference(wrong, right)))] + s = next(g for name, g, _ in items if name == 'S0') + action = next(a for a in actions if a['name'] == 'S0') + correct = multiply(multiply(s, bells[0]), transpose(s)) + wrong = multiply(multiply(s, bells[0]), adjoint(s)) + need(wrong == bells[0] and action['Bell_labels'][0] == 8, 'actual S0 congruence witness') + result.append(rejected('conjugation_in_place_of_congruence', + lambda: matrix_guard(wrong, correct, 'Bell action requires congruence'), + 'Bell action requires congruence', dict(generator='S0', input_form=0, + correct_form=8, wrong_form=0, mismatch=difference(wrong, correct)))) + result.append(rejected('degree_alone_selects_wrong_35', lambda: row_guard(chars, 8, 35, 15), + 'source constituent degree/transvection identification', + dict(wrong_published_row=8, degree=chars[7][0], actual_Tt=chars[7][30], + required_Tt=15, inherited_m9=inherited[8], correct_row=7, + correct_m9=inherited[7]))) + result.append(rejected('Y_assigned_to_symmetric_Arf0', lambda: transpose_guard(bells[9], 0), + 'transpose/Arf assignment', dict(form=9, actual_Arf=arf(9), + mismatch=difference(transpose(bells[9]), bells[9])))) + alternate = pauli(27, ((27 & 7) & (27 >> 3)).bit_count() % 4) + need(alternate != bells[27], 'multiple-Y convention witness') + result.append(rejected('tensor_Y_gauge_mislabeled_as_binary_dot', + lambda: convention_guard(27, alternate), 'wrong binary-dot Bell phase', + dict(form=27, canonical_phase=0, tensor_Y_phase=2, + mismatch=difference(alternate, bells[27]), + scope='Serialization/basis-gauge guard; the alternate phased matrix is not an illegal group element.'))) + return result + + +def parser_controls(): + return [rejected('duplicate_JSON', lambda: load('{"x":1,"x":1}'), 'duplicate JSON key', {}), + rejected('floating_JSON', lambda: load('{"x":1.0}'), 'noninteger JSON number', {}), + rejected('nonfinite_JSON', lambda: load('{"x":NaN}'), 'noninteger JSON number', {})] + + +def calculate(): + sources = authenticate() + bells = [pauli(w) for w in range(64)] + items = generators() + orbits, basis = basis_checks(bells) + actions, action_counts = generator_actions(items, bells) + pairs = ordered_pair_orbits(orbits, actions) + transvection = transvection_data(actions, orbits) + blocks, chars, inherited = source_blocks(transvection) + return dict(status='PASS_CLIFFORD_QUADRATIC_ORBIT_BLOCKS', schema_version=1, + source_sha256=sources, source_manifest_sha256=SOURCE_SHA, + conventions=dict(base_ring='Z[i,1/2]', natural_dimension=8, center_order=4, + label='a+8*b', Bell_phase='i^parity(a&b)', + Q_w='parity(a_v&b_v)+omega(v,w) mod2', + generator_alphabet='Xj,Zj,Sj,Rxj; six directed CNOT; central iI', + intertwiner='theta*bar(g_num)*B_w^dagger=B_target^dagger*g_num'), + basis_checks=basis, generator_action_counts=action_counts, generators=actions, + transpose_orbits=[dict(Arf=a, dimension=len(o), labels=o) for a, o in enumerate(orbits)], + ordered_pair_orbits=pairs, transvection=transvection, actual_width10_blocks=blocks, + witnessed_controls=controls(items, bells, actions, chars, inherited), + parser_controls=parser_controls(), predecessor_programs_executed=False, + scope='New actual-generator/Bell and ordered-pair evidence for two blocks; inherited table/group/m9/reciprocity/Gram premises; no full spectrum or endpoint claim.') + + +def main(): + need(sys.argv[1:] in ([], ['--emit']), 'only optional --emit is supported') + packet = calculate() + if not sys.argv[1:]: + need(canonical(load((P/'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_CLIFFORD_QUADRATIC_ORBIT_BLOCKS: '+str(error), file=sys.stderr) + raise SystemExit(1)