From d7c2dd1868c70f0addce2c0a4d3220149452f14b Mon Sep 17 00:00:00 2001 From: Ali Romman <226877337+aliromman@users.noreply.github.com> Date: Wed, 18 Nov 2026 20:38:37 -0500 Subject: [PATCH] Prove the sharp four-qubit Clifford tensor threshold T(4)=13 --- .../.gitattributes | 1 + .../clifford-four-qubit-threshold/CREDITS.md | 43 ++ .../EXTERNAL.json | 27 ++ .../clifford-four-qubit-threshold/PROOF.md | 378 +++++++++++++++ .../clifford-four-qubit-threshold/README.md | 44 ++ .../clifford-four-qubit-threshold/RESULT.json | 298 ++++++++++++ .../SOURCE-PINS.json | 61 +++ .../SOURCES.json | 18 + .../clifford-four-qubit-threshold/TASK.json | 101 ++++ .../clifford-four-qubit-threshold/VERIFY.json | 32 ++ .../retained/source7747/PROJECTION.json | 87 ++++ .../retained/source7747/README.md | 182 ++++++++ .../retained/source7747/SOURCES.json | 30 ++ .../retained/source7747/TASK.json | 102 ++++ .../retained/source7747/VERIFY.json | 23 + .../retained/source7747/verify.py | 179 +++++++ .../retained/three-qubit-PROOF.md | 430 +++++++++++++++++ .../clifford-four-qubit-threshold/verify.py | 437 ++++++++++++++++++ 18 files changed, 2473 insertions(+) create mode 100644 research/clifford-four-qubit-threshold/.gitattributes create mode 100644 research/clifford-four-qubit-threshold/CREDITS.md create mode 100644 research/clifford-four-qubit-threshold/EXTERNAL.json create mode 100644 research/clifford-four-qubit-threshold/PROOF.md create mode 100644 research/clifford-four-qubit-threshold/README.md create mode 100644 research/clifford-four-qubit-threshold/RESULT.json create mode 100644 research/clifford-four-qubit-threshold/SOURCE-PINS.json create mode 100644 research/clifford-four-qubit-threshold/SOURCES.json create mode 100644 research/clifford-four-qubit-threshold/TASK.json create mode 100644 research/clifford-four-qubit-threshold/VERIFY.json create mode 100644 research/clifford-four-qubit-threshold/retained/source7747/PROJECTION.json create mode 100644 research/clifford-four-qubit-threshold/retained/source7747/README.md create mode 100644 research/clifford-four-qubit-threshold/retained/source7747/SOURCES.json create mode 100644 research/clifford-four-qubit-threshold/retained/source7747/TASK.json create mode 100644 research/clifford-four-qubit-threshold/retained/source7747/VERIFY.json create mode 100644 research/clifford-four-qubit-threshold/retained/source7747/verify.py create mode 100644 research/clifford-four-qubit-threshold/retained/three-qubit-PROOF.md create mode 100644 research/clifford-four-qubit-threshold/verify.py diff --git a/research/clifford-four-qubit-threshold/.gitattributes b/research/clifford-four-qubit-threshold/.gitattributes new file mode 100644 index 0000000000..130a3ecaa2 --- /dev/null +++ b/research/clifford-four-qubit-threshold/.gitattributes @@ -0,0 +1 @@ +retained/** -text whitespace=cr-at-eol diff --git a/research/clifford-four-qubit-threshold/CREDITS.md b/research/clifford-four-qubit-threshold/CREDITS.md new file mode 100644 index 0000000000..db09795409 --- /dev/null +++ b/research/clifford-four-qubit-threshold/CREDITS.md @@ -0,0 +1,43 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared the sharp four-qubit threshold proof, the missing-block +argument, explicit character relation and checker with substantial OpenAI Codex assistance. +New material is Apache-2.0. Independent human and formal proof-kernel +acceptance are not claimed. + +Nick Petalas (@petalas) supplied the width-nine four-qubit quotient, +rank calculation and released width-ten question in +[PR #7747](https://github.com/CrocSwap/integer-mult-bounds/pull/7747). +All six files of the [source package](https://github.com/petalas/integer-mult-bounds/tree/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine) +are retained byte-exact. The [source proof](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/README.md) +supplies the tuple identification. Its [projection](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/PROJECTION.json) +and [checker](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/verify.py) +supply the separate signed-sum check and unchanged source replay. Their +notices credit the ATLAS and Thomas Breuer's CTblLib 1.3.11 for the ordinary +character table. The release archive and exact table member were authenticated, and the +unchanged source extractor rederived the retained projection. + +alephnan (@alephnan) supplied the odd-sector and quadratic-character +framework in [PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714), +whose [proof](https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md) +is retained byte-exact. That package reports substantial OpenAI Codex +assistance. Its notices retain the pointwise framework from Ali Romman's +[PR #5526](https://github.com/CrocSwap/integer-mult-bounds/pull/5526), +MatShep's small-qubit results, Nick Petalas's lower bound and the +Lee--Yu--Peng--Lai table. Those earlier numerical suites are not replayed here. + +The Dickson sign homomorphism is classical, not a new result. The proof +uses D. E. Taylor, *The Geometry of the Classical Groups*, Theorem 11.43, +printed page 160, which credits Dye (1977). +[Author's text](https://www.maths.usyd.edu.au/u/don/papers/gcg.pdf#page=168) +No book content is copied into the package. `EXTERNAL.json` records this +mathematical input. + +The new contribution is the sharp threshold T(4)=13, the complete +width-eleven quotient support, the width-twelve inflated-block obstruction, +and the complete width-thirteen support. The additional Dickson proof +gives the absent width-ten module, explicit character coefficients and +the result for qubit counts divisible by four. Seven retained source +files have exact Git blob and SHA-256 pins in `SOURCE-PINS.json`. +`SOURCES.json` records canonical selected-record and catalogue provenance. +Content pins do not assert unmerged ancestry. diff --git a/research/clifford-four-qubit-threshold/EXTERNAL.json b/research/clifford-four-qubit-threshold/EXTERNAL.json new file mode 100644 index 0000000000..26f473de73 --- /dev/null +++ b/research/clifford-four-qubit-threshold/EXTERNAL.json @@ -0,0 +1,27 @@ +{ + "schema_version": 1, + "inputs": [ + { + "author": "D. E. Taylor", + "title": "The Geometry of the Classical Groups", + "version": "Corrections: April 2021", + "url": "https://www.maths.usyd.edu.au/u/don/papers/gcg.pdf#page=168", + "theorem": "11.43", + "printed_page": 160, + "pdf_page": 168, + "used": "The rank parity of g-I defines the Dickson homomorphism on an orthogonal group.", + "verification": "Author-hosted theorem and proof read; no formal reconstruction of the theorem is claimed." + }, + { + "author": "ATLAS contributors; Thomas Breuer and CTblLib contributors", + "title": "GAP Character Table Library 1.3.11, ordinary S8(2) table", + "url": "https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/", + "archive_url": "https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/ctbllib-1.3.11.tar.gz", + "archive_sha256": "f201e9da571c681a7bbfb1e4683bdb2c80a23b005099ed0453521f59cb443434", + "table_member": "ctbllib-1.3.11/data/ctosymp1.tbl", + "table_sha256": "461519e33cb31b2bc46f554b09f283f0afb7125fd805840d79bfc614fce75b6f", + "used": "All 81 ordinary quotient rows, through the retained exact projection, for widths eleven and thirteen and the signed stabilizer sums.", + "verification": "Release archive and table member authenticated; unchanged source extractor rederived the complete retained projection. The published character table is an input, not reconstructed from group multiplication." + } + ] +} diff --git a/research/clifford-four-qubit-threshold/PROOF.md b/research/clifford-four-qubit-threshold/PROOF.md new file mode 100644 index 0000000000..d4fa0b807b --- /dev/null +++ b/research/clifford-four-qubit-threshold/PROOF.md @@ -0,0 +1,378 @@ +# The sharp four-qubit Clifford tensor threshold is thirteen + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +## Result and exact scope + +Use the full Gaussian-dyadic n-qubit Clifford group G, its natural +representation V of dimension `2^n`, the Pauli subgroup P, and scalar +`z=iI`. These are the conventions in +[PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714) +and [PR #7747](https://github.com/CrocSwap/integer-mult-bounds/pull/7747). +The scalar kernel is mu_4 and `G/P = Sp(2n,2)`. + +**The four-qubit threshold is exactly T(4)=13.** At width eleven, +exactly two odd-sector blocks are absent, with quotient degrees 595 +and 3213. At width twelve their inflated quotient modules are still +absent. All quotient rows occur at width thirteen. Thus the projective +operators are independent exactly at widths f>=13. + +| Width | Gram statement | +| --- | --- | +| 10 | Nullity at least 14,400 from a degree-120 Dickson block | +| 11 | Exact nullity 2,733,412,864; exact rank 12,125,935,463,936 | +| 12 | Nullity at least 10,677,394; full nullity is not claimed | +| 13 and above | Full rank 12,128,668,876,800 | + +Sections 1--6 give a separate table-independent obstruction. For every +positive n divisible by four, an actual module of degree +`N_minus = 2^(n-1)(2^n-1)` is absent at width `2n+2`. Its missing matrix +block has dimension `N_minus^2`, so `T(n)>=2n+3`. An explicit character +formula gives nonzero null coefficients. Section 7 strengthens the +four-qubit result to the sharp threshold using the published ordinary +Sp(8,2) character table through the retained exact projection. + +No physical supplier, new kappa, selected-frontier change or discharge +of any of the five framework assumptions follows. Classical group +representation theory and the cited published table are mathematical +inputs; they are not reconstructed in a formal proof kernel. + +## 1. The odd quotient is a tuple permutation representation + +The Pauli representation with central character `z -> i` is unique and +has dimension `2^n`. Thus every G-representation R in this sector is +`V tensor Hom_P(V,R)`. The second factor is an honest representation of +`S=Sp(2n,2)`, with action `phi -> R(g) phi V(g)^(-1)`. This does not +assume a splitting of G over P. + +For `n=4k`, write + +```text +V^(tensor (2n+1)) = V tensor W. +``` + +Let `d(s)=dim ker(s-I)` on the binary symplectic space E. The Hermitian +Pauli basis makes conjugation by a Clifford a signed permutation. On the +fixed label space, its signs form a character. Varying a lift by Paulis +runs through all those characters. Hence each s has a lift g with +`|tr V(g)|^2 = 2^d(s)` and nonzero trace. + +A Gaussian-dyadic number of this squared modulus has phase an eighth root +of unity. This follows by clearing its power-of-two denominator in the +sum-of-two-squares equation. Since `2n=8k`, character division on that lift +gives + +```text +chi_W(s) = (tr V(g))^(2n) = 2^(n d(s)). +``` + +This is the fixed-point character of S on ordered n-tuples in E, including +zero entries. Equality of complex characters gives + +```text +W is isomorphic to C[E^n]. +``` + +For n=4 this is exactly the table-independent quotient identification in +Nick Petalas's width-nine proof. The same trace argument proves the stated +extension to every n divisible by four. + +## 2. Quadratic characters and an actual stabilizer extension + +Use `W_v = i^(a.b) X^a Z^b` for `v=(a,b)` in E. The one-dimensional +Pauli characters with `z -> -1` are indexed by quadratic refinements q +of the symplectic form omega: + +```text +lambda_q(W_v) = (-1)^q(v). +``` + +The sign in Clifford conjugation is invisible in this central sector. +Thus G permutes these characters through the ordinary S action on the +quadratic forms. There are two orbits, with sizes +`2^(n-1)(2^n+1)` and `N_minus`, distinguished by the Arf invariant. + +There is an explicit extension on each stabilizer. Put +`Omega = sum_x e_x tensor e_x` and +`b_t = (I tensor W_t) Omega`. The `4^n` Bell vectors form a basis of +`V tensor V`. Direct Pauli multiplication gives + +```text +(W_v tensor W_v) b_t = (-1)^(q_0(v)+omega(v,t)) b_t, +q_0(a,b) = a.b. +``` + +Let q be one of these forms, and let T_q be its stabilizer in G. The +one-dimensional Bell line L_q is preserved by T_q. Its actual action +is a character eta_q, which extends lambda_q. No assumed abstract +extension or choice of projective stabilizer representation is needed. + +The swap of the two factors acts on b_t by `(-1)^q_0(t)`. Hence the +minus-Arf Bell lines form the exterior square `Lambda^2 V`, of dimension +`N_minus`; the plus lines form the symmetric square. The action on each +orbit is transitive. + +## 3. The Dickson sign is absent on n-tuples in minus type + +Fix a minus-type q and put `K=O(E,q)=T_q/P`. The Dickson sign is + +```text +delta(s) = (-1)^rank(s-I), s in K. +``` + +It is a group character. We use D. E. Taylor's *The Geometry of the +Classical Groups*, Theorem 11.43, printed page 160, for this standard +homomorphism theorem. [Author's text](https://www.maths.usyd.edu.au/u/don/papers/gcg.pdf#page=168) + +For q(v)=1, the map `t_v(x)=x+omega(x,v)v` preserves q. It differs from +identity by rank one, so `delta(t_v)=-1`. + +Every ordered n-tuple has a negative-sign element in its K-stabilizer. +To prove this, let U be its span. Then `dim U <= n`, so `dim U^perp >= n`. +A minus-type quadratic space of dimension 2n has no n-dimensional totally +singular subspace. Therefore `U^perp` contains a v with q(v)=1. The +transvection t_v fixes every tuple entry and has Dickson sign -1. + +Here is one direct justification of the dimension statement. The minus +normal form + +```text +q_minus(a,b) = sum_i a_i b_i + a_1 + b_1 +``` + +has `2^(2n-1)-2^(n-1)` zero vectors. If an n-dimensional subspace were +totally singular, it would be a symplectic Lagrangian. Extend its basis +to a symplectic basis. Since q vanishes on its first half, the new +quadratic expression has only hyperbolic products and linear terms on +the second half. Adjusting the paired basis vectors removes those linear +terms. This is the plus form, which has `2^(2n-1)+2^(n-1)` zeros, a +contradiction. The minus form does have an (n-1)-dimensional totally +singular subspace, but the upper bound is what is needed here. + +Now a delta-eigenvector in `C[E^n]` must have zero coefficient at every +tuple: its stabilizer contains t_v, which fixes that coefficient but +must multiply it by -1. Thus delta is absent from `W restricted to K`. +This argument uses characteristic zero for the permutation module. + +## 4. Induce the missing even-sector module + +Inflate delta from K to T_q and define + +```text +pi_minus = Ind_(T_q)^G (eta_q tensor delta). +``` + +It has degree `N_minus` and central character `z -> -1`. It is +irreducible: its restriction to P has each character in the minus orbit +once. A G-invariant subspace must be a sum of some of these distinct +one-dimensional eigenspaces, and transitivity forces either none or all. + +On the other hand, + +```text +V^(tensor (2n+2)) = (V tensor V) tensor W. +``` + +Its q-eigenspace for P is `L_q tensor W`. The T_q action there is +`eta_q tensor (W restricted to K)`. Section 3 says that this space has +no `eta_q tensor delta` constituent. Equivalently, by Frobenius +reciprocity, pi_minus has multiplicity zero in the full tensor power. +This proves the missing-constituent assertion. + +## 5. Explicit null coefficients and the Gram bound + +For any g in G, let s be its symplectic image. On a fixed minus Bell +line, the induced twist multiplies its trace contribution by +`(-1)^rank(s-I)`. This sign is the same for every q fixed by s. The +character is therefore + +```text +chi_pi_minus(g) + = (-1)^rank(s-I) chi_(Lambda^2 V)(g) + = (-1)^rank(s-I) ((tr V(g))^2 - tr V(g^2)) / 2. (1) +``` + +The rank-parity function need not be a character of the whole symplectic +group. Formula (1) follows from the induced character on the quadratic +stabilizers; it does not assert a global one-dimensional twist of V. + +Choose one unitary representative U_a per projective Clifford class. +An explicit null relation at width `f=2n+2` is + +```text +b_a = conjugate(chi_pi_minus(U_a)), +sum_a b_a U_a^(tensor f) = 0. (2) +``` + +Indeed, the central primitive idempotent +`(N_minus/|G|) sum_g chi_pi_minus(g^(-1)) [g]` acts as zero in this tensor +power. Group its four scalar lifts. Their central factors cancel because +both pi_minus and `V^(tensor f)` have central character -1. This gives (2). +The coefficient at identity is `N_minus`, so the relation is nonzero. +Formula (1) computes every coefficient from its actual operator and binary +symplectic action; no full even-sector character table is needed. + +In the central-character ideal of C[G], the pi_minus matrix block has +dimension `N_minus^2`. Semisimplicity gives the same lower bound on the +projective Gram nullity. For n=4, `|G/|=4^4 |Sp(8,2)|` is +12,128,668,876,800, giving the stated rank upper bound. + +Finally, normalized tensor Grams satisfy `H_(f+1)=H_f circle H_1` and +`diag(H_1)=1`. The Schur product theorem propagates positive definiteness +from any width to every later width: if `H_f >= cI` for c>0, then +`H_(f+1) >= cI`. Singularity at `2n+2` therefore implies `T(n)>=2n+3`. + +## 6. A separate exact quotient-table check for four qubits + +This check uses the predecessor's retained CTblLib-derived projection; +the absence proof above does not require a character table. In `Sp(8,2)`, +the minus quadratic-form permutation character is `1+chi_119`. Thus + +```text +Ind_K^S(delta)(s) = (-1)^d(s) (1+chi_119(s)), +m = (1/|S|) sum_s 2^(4d(s)) (-1)^d(s) (1+chi_119(s)). +``` + +The parity uses `rank(s-I)=8-d(s)`. Group the source projection by d. +Its nine exact numerator terms, for d=0 through 8, are + +```text +9935585280, -317939712000, 3391368069120, +-15503358689280, 33073083187200, -34139956838400, +17352338964480, -4380866641920, 515396075520. +``` + +They sum to zero. The zero-dimension character sum is recovered from +orthogonality to the trivial character, not guessed. Replacing the minus +orbit with the plus orbit `1+chi_135` gives multiplicity one. Omitting +the Dickson sign gives a positive multiplicity. These controls distinguish +the missing module from the ordinary exterior-square module and from the +other quadratic orbit. + +## 7. Widths eleven, twelve and thirteen give the sharp threshold + +Now fix n=4 and write `S=Sp(8,2)`, with order 47,377,612,800. The +complex conjugate natural representation `V*` is the unique Pauli +irreducible with central character `z -> -i`. It gives an honest quotient +multiplicity space just as V does in Section 1. Hence + +```text +V^(tensor 11) = V* tensor W11, +V^(tensor 13) = V tensor W13. +``` + +On a nonzero-trace lift g, let `a=tr V(g)` and `|a|^2=2^d`. +The exact Gaussian phase identity is `a^4=(-1)^d 2^(2d)`. Therefore + +```text +chi_W11(s) = a^11 / conjugate(a) = a^12 / |a|^2 = (-1)^d 2^(5d), +chi_W13(s) = a^12 = (-1)^d 2^(6d). (3) +``` + +Keeping this sign and using V* at width eleven are necessary. An +unsigned tuple character would describe a different representation. + +Let b_i be the degree of ordinary quotient row i, and let A_i,d be +the retained sum of `|C| chi_i(C)` over classes with fixed dimension d, +for d=1 through 7. The unique d=8 class is identity. Since the two +characters in (3) equal one at d=0, subtract the trivial character to +eliminate those columns. For p=5 or 6, the multiplicity is + +```text +m_i(p) = [i=1] + + (b_i (2^(8p)-1) + sum_(d=1)^7 A_i,d ((-1)^d 2^(pd)-1)) / |S|. +``` + +`RESULT.json` lists all 81 multiplicities at both widths. They are +nonnegative integers. Their degree-weighted sums are `2^40` and `2^48`. +At width eleven, the only zero rows are 9 and 22, of degrees 595 and +3213. Their full G-modules have dimensions 9,520 and 51,408. The exact +missing regular block dimension is + +```text +9520^2 + 51408^2 = 2,733,412,864. +``` + +At width thirteen every row has positive multiplicity; the smallest +multiplicity is 651. The complete odd central-character ideal is +therefore represented faithfully, giving the full projective Gram rank. + +Width twelve needs no even-sector table. Tensor the width-eleven +decomposition with V: + +```text +V^(tensor 12) = (V tensor V*) tensor W11. +``` + +The P-invariant part of `V tensor V* = End(V)` consists exactly of the +scalar identity, since V is Pauli-irreducible. S acts trivially on that +line. Thus the entire P-invariant subspace at width twelve is W11. +Every quotient irreducible inflated from S must occur inside this +P-invariant subspace. Rows 9 and 22 are absent there, so their inflated +G-modules of degrees 595 and 3213 are absent at width twelve. This gives + +```text +nullity H12 >= 595^2 + 3213^2 = 10,677,394 > 0. +``` + +Other nontrivial-Pauli-character blocks may also be absent at width +twelve; the stated bound does not enumerate them. Singularity at twelve, +full rank at thirteen and the Schur-product propagation in Section 5 +prove **T(4)=13** and independence at every larger width. + +The multiplicity calculation has two further exact checks. First, +recover the d=0 class sum by orthogonality and evaluate all nine bins +directly; this agrees with the subtraction formula. Second, the squared +character in (3) is the permutation character on 2p ordered vectors. +Witt's lemma counts its S-orbits by the tuple kernel and the alternating +form on its quotient. For quotient dimension r and radical dimension u, +embedding in E is possible exactly when `r+u<=8`. There are +`[2p choose r]_2` kernels, `[r choose u]_2` radicals, and +`|GL(r-u,2)|/|Sp(r-u,2)|` nondegenerate alternating forms on the quotient +by the radical. Summing these counts gives the exact character norms +at tuple lengths ten and twelve. Both the multiplicity-square sums and +the fixed-dimension histogram moments agree with these separate orbit +counts. The argument permits tuple length above eight: the quotient +rank, rather than the number of tuple positions, is at most eight. + +The original CTblLib 1.3.11 archive and its `ctosymp1.tbl` member were +SHA-256 authenticated. The unchanged predecessor extractor rederived +all 81 projected rows and fixed-dimension counts from that source. +The published table remains an input; matching bytes and character +identities do not constitute a reconstruction from group multiplication. + +## Verification and limits + +The verifier checks all 200,787 four-dimensional subspaces of F2^8. Every +one contains a nonsingular vector for the fixed minus form. A separate +extension enumeration gives singular-space counts `1,119,1071,765,0` in +dimensions zero through four. Orthogonal-complement bases verify the +fixing witnesses. All 136 nonsingular transvections preserve the form +on all 256 points and have odd Dickson sign. All 18,496 pairs have even +sign. A complete 120-element minus orthogonal group in dimension four +also checks all 14,400 sign products and exact tuple-character sums. + +Literal four-qubit calculations check all 65,536 Pauli/Bell character +pairs, 65,536 Bell inner products and 5,120 Bell images under all twenty +Gaussian Hadamard, phase and CNOT generators. They give the actual +120/136 orbits. Exterior-square traces also agree with a separate sum +of 120 two-by-two minors for each generator. Formula (1) gives twisted +characters `-64i`, `8i` and `24` on the phase, Gaussian Hadamard and +CNOT generator types, respectively. + +Scope controls exhibit a plus-type singular four-space and a five-tuple +whose minus-type orthogonal complement is singular. In the complete +small group, the sign multiplicity is zero at tuple lengths 0,1,2 and +positive at length 3. These are controls on the tuple argument, not +claims about the four-qubit width-eleven tensor. The unchanged width-nine +source checker and both exact signed quotient sums also pass. + +The all-n Dickson statement is written mathematics, supported by finite +checks at n=4. No full four-qubit group or tensor matrix was materialized. +The width-ten and width-twelve nullities remain lower bounds; more missing +blocks may exist at those widths. The exact endpoint T(4)=13 uses the +published character-table input. Other qubit congruence classes, sharp +conditioning, native implementation and full caller pricing remain open. +The full three-qubit suite, selected cold replay, Lean and Docker were +not run. No independent human or proof-kernel acceptance or global +priority is claimed. All five framework assumptions remain unchanged. diff --git a/research/clifford-four-qubit-threshold/README.md b/research/clifford-four-qubit-threshold/README.md new file mode 100644 index 0000000000..72e1681213 --- /dev/null +++ b/research/clifford-four-qubit-threshold/README.md @@ -0,0 +1,44 @@ +# The sharp four-qubit Clifford tensor threshold is thirteen + +The full Gaussian-dyadic four-qubit Clifford alphabet is pointwise +tensor-independent exactly at widths **f>=13**. Thus **T(4)=13**. +Width eleven has exact nullity **2,733,412,864**. Two inflated modules +still give nullity at least **10,677,394** at width twelve. Every quotient +row occurs at width thirteen. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), [verify.py](verify.py), +[SOURCE-PINS.json](SOURCE-PINS.json), [EXTERNAL.json](EXTERNAL.json) and +[CREDITS.md](CREDITS.md). The package also proves a table-independent +Dickson-block obstruction: **T(n)>=2n+3** for positive n divisible by four. +It gives a degree-120 missing block and explicit null coefficients at +four-qubit width ten. + +Use Python 3.12 and its standard library from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-four-qubit-threshold +``` + +Both modes print `PASS_CLIFFORD_FOUR_QUBIT_THRESHOLD`. The registered +replay uses the exact retained quotient projection. To rederive that +projection, download the CTblLib 1.3.11 archive linked in `EXTERNAL.json`, +then run: + +```sh +python3.12 -W error -B research/clifford-four-qubit-threshold/verify.py --ctbllib-archive /path/to/ctbllib-1.3.11.tar.gz +``` + +The archive and exact table member are authenticated before use. +The published ordinary table is a mathematical input, not a table +reconstructed from group multiplication. No new kappa or physical +supplier follows; all five assumptions remain. + +## Open next questions + +- Determine the full width-ten and width-twelve nullities. The reported + missing blocks need not be the only ones in those even sectors. +- Test other qubit counts or exact conditioning. Retain the Gaussian + phase and the correct natural or conjugate odd sector. No physical + caller price follows from a tensor-alphabet threshold alone. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/clifford-four-qubit-threshold/RESULT.json b/research/clifford-four-qubit-threshold/RESULT.json new file mode 100644 index 0000000000..bbd3a1de1d --- /dev/null +++ b/research/clifford-four-qubit-threshold/RESULT.json @@ -0,0 +1,298 @@ +{ + "geometry": { + "four_spaces": 200787, + "nonsingular_histogram": { + "4": 10710, + "6": 45696, + "8": 87975, + "10": 45696, + "12": 10710 + }, + "singular_space_counts": [ + 1, + 119, + 1071, + 765, + 0 + ], + "chosen_transvections": 104 + }, + "sign": { + "transvections": 136, + "isometry_points": 34816, + "transvection_pairs": 18496, + "small_group_order": 120, + "small_group_pairs": 14400, + "small_sign_multiplicities": [ + 0, + 0, + 0, + 7, + 273 + ] + }, + "literal_bell": { + "character_controls": [ + [ + "CNOT", + 24, + 0, + 24, + 0, + 12 + ], + [ + "H", + 0, + -8, + 0, + 8, + 4 + ], + [ + "S", + 0, + 64, + 0, + -64, + 4 + ] + ], + "pauli_character_pairs": 65536, + "bell_inner_products": 65536, + "literal_clifford_generators": 20, + "literal_bell_images": 5120, + "orbits": [ + 120, + 136 + ] + }, + "quotient_check": [ + { + "orbit_size": 120, + "signed_terms": [ + 9935585280, + -317939712000, + 3391368069120, + -15503358689280, + 33073083187200, + -34139956838400, + 17352338964480, + -4380866641920, + 515396075520 + ], + "multiplicity": 0, + "unsigned_multiplicity": 2294 + }, + { + "orbit_size": 136, + "signed_terms": [ + 9935650816, + -317939712000, + 3391345786880, + -15503358689280, + 33074580553728, + -34139956838400, + 17329521950720, + -4380866641920, + 584115552256 + ], + "multiplicity": 1, + "unsigned_multiplicity": 2295 + } + ], + "threshold": { + "width11_multiplicities": [ + 1, + 24904, + 25245, + 50303, + 154, + 495, + 56848, + 748, + 0, + 6545, + 75735, + 19635, + 15895, + 272052, + 157080, + 6545, + 353430, + 5236, + 300696, + 163625, + 369325, + 0, + 439263, + 16830, + 39270, + 13090, + 314160, + 277508, + 33880, + 5236, + 117810, + 327250, + 163625, + 263109, + 370260, + 39270, + 294525, + 714560, + 106029, + 729300, + 130900, + 327250, + 35904, + 377740, + 157080, + 824670, + 100980, + 106029, + 176715, + 318087, + 1060290, + 530145, + 78540, + 589050, + 323136, + 193732, + 1047200, + 1309000, + 1472625, + 294525, + 549780, + 1378377, + 1172864, + 353430, + 530145, + 1060290, + 227205, + 1136025, + 494208, + 418880, + 424116, + 1403325, + 1403325, + 1017280, + 1309000, + 530145, + 1272348, + 1472625, + 1099560, + 1396736, + 1136025 + ], + "width13_multiplicities": [ + 651, + 1518660, + 1611753, + 3148145, + 118482, + 211575, + 5425992, + 620620, + 620620, + 2637635, + 9570847, + 4765475, + 4765475, + 28353468, + 22608300, + 3878875, + 38434110, + 4592588, + 36173280, + 28260375, + 42578965, + 6330324, + 49512177, + 7757750, + 15825810, + 7757750, + 45216600, + 42503604, + 12412400, + 10550540, + 29089346, + 56520750, + 39564525, + 51622285, + 67824900, + 26376350, + 62172825, + 106392000, + 42729687, + 113041500, + 52752700, + 79129050, + 33761728, + 82897100, + 63303240, + 137910630, + 48532484, + 55390335, + 65940875, + 87041955, + 169562250, + 118693575, + 52752700, + 124345650, + 93447640, + 73853780, + 195938600, + 226083000, + 254343375, + 118693575, + 158258100, + 250273881, + 231508992, + 131881750, + 166171005, + 237387150, + 118693575, + 254343375, + 158878720, + 168808640, + 170918748, + 314188875, + 314188875, + 265270720, + 316516200, + 213648435, + 322846524, + 356080725, + 316516200, + 381308928, + 356080725 + ], + "width11_missing_rows": [ + 9, + 22 + ], + "width11_missing_quotient_degrees": [ + 595, + 3213 + ], + "width11_nullity": 2733412864, + "width11_rank": 12125935463936, + "width12_nullity_lower": 10677394, + "width12_rank_upper": 12128658199406, + "width13_rank": 12128668876800, + "threshold": 13, + "quotient_norms": [ + 32706956587383, + 1779648049240119735 + ], + "minimum_width13_multiplicity": 651 + }, + "four_qubit": { + "projective_order": 12128668876800, + "missing_block_degree": 120, + "nullity_lower": 14400, + "rank_upper": 12128668862400, + "threshold_lower": 11 + } +} diff --git a/research/clifford-four-qubit-threshold/SOURCE-PINS.json b/research/clifford-four-qubit-threshold/SOURCE-PINS.json new file mode 100644 index 0000000000..6a30697dde --- /dev/null +++ b/research/clifford-four-qubit-threshold/SOURCE-PINS.json @@ -0,0 +1,61 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "petalas/integer-mult-bounds", + "commit": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/PROJECTION.json", + "retained": "retained/source7747/PROJECTION.json", + "git_blob": "406f84b46901df771050eac3f367413cc6529ba1", + "sha256": "0a36754668b66480e5f968c117a4532bc3a5eaab5c9d8448f14a5d0321c2efae" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/README.md", + "retained": "retained/source7747/README.md", + "git_blob": "d31d4d24c9f5ad26d26ccfd1a01f8754e81a6241", + "sha256": "7e841784df881cda0215da6bb005c80d050659a2f33f56e923509994b50ea6b7" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/SOURCES.json", + "retained": "retained/source7747/SOURCES.json", + "git_blob": "1ad5bd2e2ece2ba9433231a90eec80e98b3ef91d", + "sha256": "270105bede250b3655a2b3e2ec1a5a093e3238f0049c999ae47d4109c9bcbe4a" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/TASK.json", + "retained": "retained/source7747/TASK.json", + "git_blob": "819c9ff42e45011f64596f027a0be3eb81e7ace5", + "sha256": "f9bc51d9a73a22a2293e76bc9bf5b7b807575411ff0e2e56e8a6abeb6dc63c6a" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/VERIFY.json", + "retained": "retained/source7747/VERIFY.json", + "git_blob": "659494422c6292d6d3991abdd2d98d950ed6bea8", + "sha256": "1444255057db7cd77fd9796c5a5be36daed4bae586f711c147b2c2c366fff043" + }, + { + "repository": "petalas/integer-mult-bounds", + "commit": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/verify.py", + "retained": "retained/source7747/verify.py", + "git_blob": "4914eea2769af2b509fe1101b8dc3787a078fe56", + "sha256": "b32453df8dbb47af441ff736c51709c8e0c53fc2e13609f3841d48d977f8839b" + }, + { + "repository": "alephnan/integer-mult-bounds", + "commit": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0", + "path": "research/clifford-three-qubit-threshold/PROOF.md", + "retained": "retained/three-qubit-PROOF.md", + "git_blob": "9f89ee36a0a1a0bdda09582d88477e15674fda5e", + "sha256": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0" + } + ] +} diff --git a/research/clifford-four-qubit-threshold/SOURCES.json b/research/clifford-four-qubit-threshold/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/clifford-four-qubit-threshold/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/clifford-four-qubit-threshold/TASK.json b/research/clifford-four-qubit-threshold/TASK.json new file mode 100644 index 0000000000..8899527d79 --- /dev/null +++ b/research/clifford-four-qubit-threshold/TASK.json @@ -0,0 +1,101 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "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": "Sharp pointwise tensor threshold T(4)=13 for the full Gaussian-dyadic four-qubit Clifford group, exact width-eleven support and width-twelve inflated-block lower bound; supporting Dickson obstruction for positive n divisible by four.", + "scope_change_reason": "The released width-ten question led to a missing Dickson block. The same source projection settles width eleven, the Pauli-invariant width-twelve obstruction and width-thirteen completeness, so all are included as one result.", + "bottleneck_link": "Exact native tensor-independence tests need the correct width threshold and retained scalar phases.", + "budget_minutes": 60, + "stop_rule": "Stop after the sharp four-qubit threshold and its exact multiplicities are proved and checked; leave full even-sector ranks, other qubit congruences and physical costs explicit.", + "outcome": "completed", + "evidence": "PROOF.md proves T(4)=13. RESULT.json gives all 81 multiplicities at widths eleven and thirteen, exact norm and dimension checks, and finite Dickson/Pauli/Clifford evidence. The original table projection was rederived from the authenticated archive.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "What are the full width-ten and width-twelve nullities?", + "why_it_matters": "The given even-sector missing blocks need not be the only ones.", + "first_step": "Decompose the remaining exact quadratic or vector stabilizer restrictions.", + "blocked_by": "Full even-sector support is not enumerated." + }, + { + "question": "What are the sharp thresholds and conditioning at other qubit counts?", + "why_it_matters": "The tuple argument only covers n divisible by four and gives a lower bound.", + "first_step": "Retain phases in the natural or conjugate odd sector and use exact quotient characters.", + "blocked_by": "Other complete quotient calculations and physical caller prices are not supplied." + } + ] +} diff --git a/research/clifford-four-qubit-threshold/VERIFY.json b/research/clifford-four-qubit-threshold/VERIFY.json new file mode 100644 index 0000000000..5ddaf52c4c --- /dev/null +++ b/research/clifford-four-qubit-threshold/VERIFY.json @@ -0,0 +1,32 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check the sharp threshold with all 81 exact width-eleven and width-thirteen multiplicities, independent tuple norms, dimensions and controls; replay the Dickson geometry, literal Pauli/Clifford checks and unchanged source." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check the sharp threshold with all 81 exact width-eleven and width-thirteen multiplicities, independent tuple norms, dimensions and controls; replay the Dickson geometry, literal Pauli/Clifford checks and unchanged source." + } + ] +} diff --git a/research/clifford-four-qubit-threshold/retained/source7747/PROJECTION.json b/research/clifford-four-qubit-threshold/retained/source7747/PROJECTION.json new file mode 100644 index 0000000000..406f84b469 --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/source7747/PROJECTION.json @@ -0,0 +1,87 @@ +{ + "class_counts": [14, 16, 20, 12, 10, 4, 3, 1, 1], + "element_counts": [19871236096, 19871232000, 6623744000, 946249920, 63083328, 2034900, 32300, 255, 1], + "rows": [ + [1, 19871232000, 6623744000, 946249920, 63083328, 2034900, 32300, 255], + [35, -6624092160, 4415756800, -1261552320, 168218400, -10859940, 345100, -5355], + [51, -6624092160, 4415669760, -1261552320, 168241248, -10859940, 343740, -5355], + [85, -13247139840, 8831774720, -2523447360, 336436800, -21698460, 689180, -10965], + [119, 0, 6623787520, 2838749760, 441571872, 30523500, 1001980, 16065], + [135, 0, 6623700480, 2838749760, 441594720, 30523500, 1000620, 16065], + [238, 1023590400, -219950080, -198092160, 94202304, -14351400, 918680, -24990], + [510, -576552960, -753331200, 59633280, 111384000, 20948760, 1479000, 44370], + [595, -541040640, -730831360, 49008960, 108013920, 21355740, 1611260, 51765], + [595, -36556800, -15232000, 11995200, 1599360, -749700, -59500, 8925], + [918, 1015234560, -204456960, -195350400, 89861184, -14522760, 1119960, -22950], + [1190, -584908800, -737838080, 62375040, 107042880, 20777400, 1680280, 46410], + [1275, -532684800, -731788800, 46267200, 108813600, 21527100, 1555500, 49725], + [1512, 3948134400, -888330240, -748500480, 369726336, -59119200, 4112640, -128520], + [1785, -570286080, -37470720, 171702720, -26560800, -6875820, 1663620, -101745], + [1785, -1118638080, -1476894720, 110013120, 217627200, 41961780, 3163020, 112455], + [2295, 4963368960, -1103362560, -944879040, 462157920, -73320660, 5113260, -167535], + [2856, -2193408000, -2935511040, 205632000, 433335168, 84823200, 6397440, 214200], + [2856, 3948134400, -895641600, -748500480, 371645568, -59119200, 3998400, -128520], + [2975, -255897600, 6092800, 73684800, -17707200, -2034900, 987700, -98175], + [2975, 4971724800, -1104320000, -947620800, 462957600, -73149300, 5057500, -169575], + [3213, 658022400, 435939840, -194322240, -66933216, 6747300, 2634660, 176715], + [3213, 5988003840, -1316044800, -1144342080, 554589504, -87329340, 6104700, -208845], + [3400, -2193408000, -2938470400, 205632000, 434112000, 84823200, 6351200, 214200], + [3570, -219340800, -91392000, 71971200, 9596160, -4498200, -357000, 53550], + [3570, -2237276160, -2953789440, 220026240, 435254400, 83923560, 6326040, 224910], + [3570, -1140572160, -74941440, 343405440, -53121600, -13751640, 3327240, -203490], + [3808, -877363200, -53616640, 263208960, -41857536, -10281600, 2589440, -171360], + [4200, -2193408000, -2942822400, 205632000, 435254400, 84823200, 6283200, 214200], + [4760, 848117760, 569067520, -249500160, -87964800, 8396640, 3465280, 242760], + [5712, 175472640, 248586240, -49351680, -50448384, 1028160, 2170560, 85680], + [5950, -511795200, 12185600, 147369600, -35414400, -4069800, 1975400, -196350], + [5950, 219340800, 39603200, -71971200, 3998400, 4498200, -452200, -53550], + [7140, -263208960, 113326080, 78140160, -44553600, -2827440, 2199120, -64260], + [8160, -877363200, -77291520, 263208960, -35642880, -10281600, 2219520, -171360], + [8925, 877363200, 635174400, -251899200, -101959200, 6747300, 4034100, 348075], + [8925, -658022400, -105100800, 200491200, -14565600, -8675100, 1035300, -80325], + [8960, -2339635200, -136478720, 701890560, -113326080, -27417600, 7006720, -456960], + [9639, -592220160, -246758400, 194322240, 25909632, -12145140, -963900, 144585], + [10200, -2068070400, -96614400, 616896000, -106243200, -23133600, 6446400, -459000], + [11900, -731136000, -304640000, 239904000, 31987200, -14994000, -1190000, 178500], + [11900, 438681600, 79206400, -143942400, 7996800, 8996400, -904400, -107100], + [13056, 1804861440, 1245020160, -526417920, -195213312, 16450560, 7703040, 587520], + [13600, -167116800, 309862400, 54835200, -86822400, -3427200, 4025600, 40800], + [14280, -877363200, -365568000, 287884800, 38384640, -17992800, -1428000, 214200], + [14280, -2017935360, -102359040, 600445440, -101445120, -22105440, 6111840, -471240], + [14688, 1579253760, 1071636480, -460615680, -166150656, 14394240, 6462720, 514080], + [16065, 723824640, 625121280, -194322240, -107956800, 1349460, 4305420, 498015], + [16065, 789626880, 567544320, -223110720, -89964000, 4948020, 3405780, 369495], + [16065, 921231360, 452390400, -280687680, -53978400, 12145140, 1606500, 112455], + [16065, -2632089600, -90478080, 780373440, -143428320, -27953100, 8546580, -658665], + [16065, 1118638080, 279659520, -367053120, 0, 22940820, -1092420, -273105], + [17850, 1754726400, 1270348800, -503798400, -203918400, 13494600, 8068200, 696150], + [17850, -1316044800, -210201600, 400982400, -29131200, -17350200, 2070600, -160650], + [18360, 1015234560, 549918720, -304335360, -71971200, 11823840, 2350080, 201960], + [19040, 1579253760, 1047961600, -460615680, -159936000, 14394240, 6092800, 514080], + [23800, -1900953600, -115763200, 562060800, -90249600, -19706400, 5331200, -499800], + [23800, -2047180800, 48742400, 589478400, -141657600, -16279200, 7901600, -785400], + [26775, -2303078400, 54835200, 663163200, -159364800, -18314100, 8889300, -883575], + [26775, -1645056000, -685440000, 539784000, 71971200, -33736500, -2677500, 401625], + [28560, -350945280, -270520320, 115153920, 47980800, -7197120, -2513280, 85680], + [28917, -2368880640, -74027520, 694008000, -130473504, -22555260, 7518420, -722925], + [30464, -2339635200, -253460480, 701890560, -82618368, -27417600, 5178880, -456960], + [32130, 1579253760, 1135088640, -446221440, -179928000, 9896040, 6811560, 738990], + [32130, -921231360, -477066240, 302279040, 64774080, -18892440, -2955960, 224910], + [32130, 2237276160, 559319040, -734106240, 0, 45881640, -2184840, -546210], + [34425, 1551052800, 1339545600, -416404800, -231336000, 2891700, 9225900, 1067175], + [34425, 2397081600, 599270400, -786542400, 0, 49158900, -2340900, -585225], + [34560, 1804861440, 1128038400, -526417920, -164505600, 16450560, 5875200, 587520], + [38080, -2339635200, -974848000, 767692800, 102359040, -47980800, -3808000, 571200], + [38556, -2368880640, -987033600, 777288960, 103638528, -48580560, -3855600, 578340], + [42525, 2961100800, 740275200, -971611200, 0, 60725700, -2891700, -722925], + [42525, 2961100800, 740275200, -971611200, 0, 60725700, -2891700, -722925], + [43520, 534773760, -61276160, -175472640, 51179520, 10967040, -3568640, -130560], + [47600, 1754726400, 316825600, -575769600, 31987200, 35985600, -3617600, -428400], + [48195, -2961100800, -1233792000, 971611200, 129548160, -60725700, -4819500, 722925], + [51408, 1052835840, 65802240, -345461760, 51819264, 21591360, -4112640, -257040], + [53550, 1974067200, 356428800, -647740800, 35985600, 40483800, -4069800, -481950], + [57120, -701890560, -541040640, 230307840, 95961600, -14394240, -5026560, 171360], + [65536, 0, -356515840, 0, 93585408, 0, -5570560, 0], + [68850, -1974067200, -1022284800, 647740800, 138801600, -40483800, -6334200, 481950] + ] +} diff --git a/research/clifford-four-qubit-threshold/retained/source7747/README.md b/research/clifford-four-qubit-threshold/retained/source7747/README.md new file mode 100644 index 0000000000..d31d4d24c9 --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/source7747/README.md @@ -0,0 +1,182 @@ +# Exact width-nine rank for the four-qubit Clifford alphabet + +This scoped proof was produced by Nick Petalas. For the full projective +four-qubit Gaussian-dyadic Clifford alphabet, the tensor Gram matrix at +width nine has **rank 10,107,260,791,808** out of **12,128,668,876,800**. +Its nullity is **2,021,408,084,992**. In particular, the pointwise +tensor-independence threshold satisfies **T(4) ≥ 10**. + +This answers the width-nine step of alephnan's four-qubit question. The +calculation reduces the Gram rank to 81 exact character inner products in +\(\operatorname{Sp}(8,2)\). Twenty quotient irreducibles are absent. +[PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714) + +## Proof + +### From tensor rank to quotient characters + +Let \(G\) be the group of all four-qubit unitary Clifford matrices over +\(\mathbb Z[i,1/2]\), \(V\) its 16-dimensional natural representation, and +\(P\) its Pauli subgroup including \(z=iI\). The scalar kernel has order +four. The Gaussian-dyadic phase gate, the Gaussian-dyadic version +\((1+i)H/\sqrt{2}\) of the normalized Hadamard \(H\), and CNOT realize the +usual symplectic generators. Consequently \(S=G/P=\operatorname{Sp}(8,2)\) +and \(|G/\langle z\rangle|=256|S|\). + +In the central sector \(z\mapsto i\) every irreducible of \(G\) has the +form \(V\otimes\sigma\) for a unique \(\sigma\in\operatorname{Irr}(S)\). +The restriction of \(V\) to \(P\) is the unique irreducible with that +central character. For any representation \(R\) in this sector, +\(\operatorname{Hom}_P(V,R)\) is a quotient representation under the +action \(\phi\mapsto R(g)\phi V(g)^{-1}\), and evaluation recovers +\(R\). Write \(V^{\otimes 9}=V\otimes W\) in this way. +These are the odd-sector reductions used for three qubits in the pinned +predecessor. [PR #6714, proof §§1–3](../clifford-three-qubit-threshold/PROOF.md) + +For \(s\in S\), write \(d(s)=\dim\ker(s-I)\) on the symplectic label +space. A lift of \(s\) acts by signed permutation of the Hermitian Pauli +basis. Its adjoint trace is the sum of its signs on fixed labels. +Those signs form a character on the fixed space by multiplicativity of +Pauli conjugation. Multiplication of the lift by a Pauli adds an arbitrary +binary character on the fixed space, by nondegeneracy of the symplectic +pairing on the full label space. Hence a lift \(g\) exists with +\(|\operatorname{tr}V(g)|^2=2^{d(s)}\). For a Gaussian-dyadic trace of +this squared modulus, clearing a power-of-two denominator and repeatedly +dividing out common factors of two shows that the trace is on an axis or +a diagonal of the Gaussian plane. Its eighth power is \(2^{4d(s)}\). +The trace is nonzero, so the tensor factorization gives + +\[ +\chi_W(s)=\operatorname{tr}(V(g))^8 = 2^{4d(s)}. +\] + +This is the permutation character on ordered four-tuples of vectors in +\(\mathbb F_2^8\). It includes the zero vector in each coordinate. + +### Identifying the fixed dimensions + +The permutation character on all vectors is +\(2+\chi_{119}+\chi_{135}\). To see this, the action on quadratic +refinements of the symplectic form has the same fixed-point count as +the action on vectors. For any \(s\), start with a refinement \(Q\). +The functional \(Q\circ s-Q\) is linear and vanishes on \(\ker(s-I)\). +It is therefore \(\ell\circ(s-I)\) for a linear \(\ell\), so \(Q+\ell\) +is fixed. All other fixed refinements differ by an \(s\)-invariant +functional, giving exactly \(2^{d(s)}\) of them. + +The refinement orbits of the two Arf signs have sizes 120 and 136. +For example, writing \(Q(a,b)=a\cdot b+\alpha\cdot a+\beta\cdot b\), +the sign is determined by \(\alpha\cdot\beta\) and counting the pairs +gives the sizes. For fixed \(Q\), refinements of its sign other than +itself correspond to nonzero singular vectors via +\(v\mapsto Q+\omega(v,\cdot)\). Witt's lemma makes the stabilizer of +\(Q\) transitive on those vectors. Each orbit action is thus doubly +transitive and its augmentation character is irreducible. Their degrees +are 119 and 135, unique in the ordinary table. [Independent identification of the orbit characters](https://link.springer.com/article/10.1007/s13370-024-01197-2) + +### Exact inner products and nullity + +Use the ordinary `S8(2)` table in Thomas Breuer's GAP Character Table +Library, release 1.3.11, which attributes this table to the ATLAS. +For row \(i\) of degree \(b_i\), define the integer +\(A_{i,d}=\sum_{C:d(C)=d}|C|\chi_i(C)\) for \(1\le d\le 7\), +summing over conjugacy classes \(C\). The unique dimension-eight column +is the identity. Subtract the trivial character from \(\chi_W\) to +eliminate every dimension-zero column. In the positive-dimension columns +all table values are integers. Row 73 is Galois conjugate to row 72 and +has the same retained values. Therefore the multiplicities are + +\[ +m_i = \mathbf 1_{i=1} + +\frac{b_i(2^{32}-1)+\sum_{d=1}^7 A_{i,d}(2^{4d}-1)}{47{,}377{,}612{,}800}. +\] + +[PROJECTION.json](PROJECTION.json) records the degree and seven sums +for each row in library order. The zero multiplicities occur at rows +\(2,4,7,14,15,17,20,23,27,32,38,40,51,52,58,59,66,68,72,73\). +The sum of their squared quotient degrees is \(7{,}896{,}125{,}332\). +[CTblLib 1.3.11 and source information](https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/) + +The group algebra ideal with central character \(i\) has a basis indexed +by projective classes. By semisimplicity its block for \(V\otimes\sigma\) +has dimension \((16\dim\sigma)^2\), and tensor evaluation is injective +on that block precisely when it occurs. The missing blocks thus have +total dimension \(256\cdot7{,}896{,}125{,}332=2{,}021{,}408{,}084{,}992\). +Subtracting from \(256|S|\) gives the stated Gram rank. The normalized +Gram matrix at width \(f+1\) is the Schur product of those at widths +\(f\) and one. Since the latter has unit diagonal, positive definiteness +at any earlier width would propagate to width nine. + +### Checks independent of the table arithmetic + +The verifier counts symplectic orbits on ordered \(k\)-tuples for +\(0\le k\le 8\) by Witt's lemma. Regard a tuple as a linear map from +\(\mathbb F_2^k\) into the label space. An orbit is specified by the +kernel and the alternating form induced on the quotient. For quotient +dimension \(r\) and radical dimension \(u\), the form embeds exactly +when \(r+u\le8\). There are \({k\brack r}_2\) kernels, +\({r\brack u}_2\) radicals, and +\(|\mathrm{GL}(r-u,2)|/|\mathrm{Sp}(r-u,2)|\) nondegenerate forms +on the remaining quotient. This follows by choosing the radical and +using transitivity of \(\mathrm{GL}\) on symplectic bases up to the form's +stabilizer. + +Burnside's lemma then checks each of the nine moments of the +fixed-dimension histogram. The verifier also checks +\(\sum_i b_i^2=|S|\), \(\sum_i b_i m_i=2^{32}\), and +\(\sum_i m_i^2\) against the eight-tuple orbit count. Two failure +controls change one character sum and move one element between +fixed-dimension bins, respectively. + +## Reproduce + +Run these from the repository root with CPython 3.12.15 and the standard +library. + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-four-qubit-width-nine +python3.12 -B scripts/check_research_commit.py --package research/clifford-four-qubit-width-nine --check-source-history +python3.12 -B -W error research/clifford-four-qubit-width-nine/verify.py +``` + +The registered replay uses the derived integer projection as input. To +rederive every projection entry from the external table, run the following +optional check. It authenticates the release archive and exact table member +before reading the 81 rows and compares the complete projection. + +```sh +scratch_dir=$(mktemp -d) +curl -fsSL 'https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/ctbllib-1.3.11.tar.gz' \ + -o "$scratch_dir/ctbllib-1.3.11.tar.gz" +python3.12 -B -W error research/clifford-four-qubit-width-nine/verify.py \ + --ctbllib-archive "$scratch_dir/ctbllib-1.3.11.tar.gz" +``` + +The archive SHA-256 is +`f201e9da571c681a7bbfb1e4683bdb2c80a23b005099ed0453521f59cb443434`. +The SHA-256 of `ctbllib-1.3.11/data/ctosymp1.tbl` is +`461519e33cb31b2bc46f554b09f283f0afb7125fd805840d79bfc614fce75b6f`. +The proof takes the published ordinary character table as input. +Formal proof-kernel review remains open. The computation concerns exact +Clifford operators at one width. It leaves physical implementation, +recursive costs and the five selected framework assumptions outside +its scope. + +## Open next questions + +- Is width ten already independent? Use the twenty missing odd-sector + rows as the only possible constituents of the reciprocity obstruction + for a missing even-sector irreducible. The remaining step is to rule + out, or realize, such a combination using the two quadratic-form + stabilizers. The width-nine rank alone does not decide this. + +## Credit + +Credit alephnan's [PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714) +for the four-qubit question and the odd-sector reduction, Ali Romman's +[PR #5526](https://github.com/CrocSwap/integer-mult-bounds/pull/5526) for the +pointwise framework, and Nick Petalas's +[PR #5967](https://github.com/CrocSwap/integer-mult-bounds/pull/5967) for the +general lower bound \(2n+1\). The published character table data are +credited to the ATLAS and Thomas Breuer's CTblLib. The new calculation, +proof and checker are Apache-2.0. diff --git a/research/clifford-four-qubit-threshold/retained/source7747/SOURCES.json b/research/clifford-four-qubit-threshold/retained/source7747/SOURCES.json new file mode 100644 index 0000000000..1ad5bd2e2e --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/source7747/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/clifford-three-qubit-threshold/PROOF.md", + "usage": "input", + "git_blob": "9f89ee36a0a1a0bdda09582d88477e15674fda5e", + "sha256": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0" + }, + { + "path": "research/clifford-three-qubit-threshold/README.md", + "usage": "input", + "git_blob": "de2ba2b2222ea47f0f0e17e5616d27e47c3df839", + "sha256": "f423d61edea2e1975ec3e466edd95ea308dcd1a6e8d2d1ba820209da07f10c87" + } + ] +} diff --git a/research/clifford-four-qubit-threshold/retained/source7747/TASK.json b/research/clifford-four-qubit-threshold/retained/source7747/TASK.json new file mode 100644 index 0000000000..819c9ff42e --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/source7747/TASK.json @@ -0,0 +1,102 @@ +{ + "schema_version": 1, + "task_id": "formal-interface-lemma", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "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": "Determine the exact rank of the width-nine full projective four-qubit Gaussian-dyadic Clifford tensor Gram.", + "scope_change_reason": "The first open question in alephnan's PR #6714 calls for a bounded four-qubit character calculation. This written algebraic side result addresses that step outside the original formal caller gate.", + "bottleneck_link": "Pointwise tensor independence is one exact native-algebra tool. The result supplies an obstruction at width nine without supplying a paid native caller.", + "budget_minutes": 60, + "stop_rule": "Stop after the width-nine multiplicities and rank replay from the pinned ordinary character table.", + "outcome": "completed", + "claim_type": "scoped proof", + "evidence": "81 exact quotient multiplicities, 20 missing rows, Gram rank 10107260791808, nullity 2021408084992, an independent nine-moment histogram check, and two rejection controls.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "Is the full four-qubit Clifford tensor Gram independent at width ten?", + "why_it_matters": "Width-ten independence would make the new lower bound sharp.", + "first_step": "Apply tensor reciprocity to the twenty missing width-nine rows and test the two quadratic-form stabilizer restrictions.", + "blocked_by": "The admissible even-sector multiplicity spaces have not been determined." + } + ], + "verified_python": "CPython 3.12.15", + "predecessor": { + "pull_request": 6714, + "author": "alephnan", + "head": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0" + } +} diff --git a/research/clifford-four-qubit-threshold/retained/source7747/VERIFY.json b/research/clifford-four-qubit-threshold/retained/source7747/VERIFY.json new file mode 100644 index 0000000000..659494422c --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/source7747/VERIFY.json @@ -0,0 +1,23 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/clifford-three-qubit-threshold/PROOF.md", + "research/clifford-three-qubit-threshold/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "-W", + "error", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Check all 81 multiplicities and the Gram rank. Check the nine fixed-dimension histogram moments by a separate tuple orbit count and reject two altered inputs." + } + ] +} diff --git a/research/clifford-four-qubit-threshold/retained/source7747/verify.py b/research/clifford-four-qubit-threshold/retained/source7747/verify.py new file mode 100644 index 0000000000..4914eea276 --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/source7747/verify.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +"""Verify the width-nine quotient calculation, optionally from its source archive.""" + +import argparse +from hashlib import sha256 +from io import BytesIO +import json +from math import prod +from pathlib import Path +import re +import tarfile + +ORDER = 47_377_612_800 +N_CLASSES = 81 +ARCHIVE_SHA256 = "f201e9da571c681a7bbfb1e4683bdb2c80a23b005099ed0453521f59cb443434" +TABLE_SHA256 = "461519e33cb31b2bc46f554b09f283f0afb7125fd805840d79bfc614fce75b6f" +TABLE_MEMBER = "ctbllib-1.3.11/data/ctosymp1.tbl" +MISSING_ROWS = [2, 4, 7, 14, 15, 17, 20, 23, 27, 32, 38, 40, 51, 52, 58, 59, 66, 68, 72, 73] + + +def require(test, message): + if not test: + raise ValueError(message) + + +def read_bounded(path, limit): + with path.open("rb") as stream: + data = stream.read(limit + 1) + require(len(data) <= limit, f"{path.name} exceeds its byte bound") + return data + + +def read_table(archive): + raw = read_bounded(archive, 20 * 1024 * 1024) + require(sha256(raw).hexdigest() == ARCHIVE_SHA256, "CTblLib archive hash") + with tarfile.open(fileobj=BytesIO(raw), mode="r:gz") as tar: + member = tar.getmember(TABLE_MEMBER) + require(member.isfile() and 0 < member.size < 256 * 1024, "table member size") + stream = tar.extractfile(member) + require(stream is not None, "missing table payload") + with stream: + data = stream.read(member.size + 1) + require(sha256(data).hexdigest() == TABLE_SHA256, "CTblLib table hash") + return data.decode("ascii") + + +def table_projection(table): + block = table.split('MOT("S8(2)",\n', 1)[1].split('\nARC("S8(2)"', 1)[0] + numbers = block.split("],\n", 1)[1] + centralizers = json.loads(numbers.split("],\n", 1)[0] + "]") + # This sequence follows the power-map argument in the MOT record. + entries = block.split("\n[[1,1,1,", 1)[1].split("]],\n", 1)[0] + entries = re.sub(r"\s+", "", "1,1,1," + entries) + require(entries.count("[GALOIS,[72,3]]") == 1, "Galois row") + entries = entries.replace("[GALOIS,[72,3]]", "GALOIS") + rows = [row.split(",") for row in re.split(r"\],\[|\],(?=GALOIS)|(?<=GALOIS),\[", entries)] + require(len(centralizers) == len(rows) == N_CLASSES, "table dimensions") + require(rows[72] == ["GALOIS"], "Galois row index") + # Galois rows agree on rational values. The only irrational entries + # occur on dimension-zero columns, which carry zero weight. + rows[72] = rows[71] + require(all(len(row) == N_CLASSES for row in rows), "table row lengths") + fixed = [2 + int(a) + int(b) for a, b in zip(rows[4], rows[5], strict=True)] + require([int(rows[i][0]) for i in (4, 5)] == [119, 135], "point character rows") + require(all(1 <= n <= 256 and n.bit_count() == 1 for n in fixed), "fixed-point powers") + dims = [n.bit_length() - 1 for n in fixed] + require(all(c > 0 and ORDER % c == 0 for c in centralizers), "centralizers") + sizes = [ORDER // c for c in centralizers] + columns = [tuple(j for j, dim in enumerate(dims) if dim == d) for d in range(9)] + require(columns[8] == (0,) and sizes[0] == 1, "identity class") + return { + "class_counts": [len(column) for column in columns], + "element_counts": [sum(sizes[j] for j in column) for column in columns], + "rows": [ + [int(row[0]), *(sum(sizes[j] * int(row[j]) for j in column) + for column in columns[1:8])] + for row in rows + ], + } + + +def gaussian_binomial(n, r): + """Number of r-subspaces of a binary n-space for 0 <= r <= n <= 8.""" + top = prod(2**n - 2**i for i in range(r)) + bottom = prod(2**r - 2**i for i in range(r)) + return top // bottom + + +def tuple_orbits(length): + """Count ordered-tuple orbits by the kernel and induced alternating form.""" + result = 0 + for rank in range(length + 1): + for radical in range(rank % 2, rank + 1, 2): + if rank + radical > 8: + continue + even = rank - radical + gl_order = prod(2**even - 2**i for i in range(even)) + half = even // 2 + sp_order = 2**(half**2) * prod(2**(2*i) - 1 for i in range(1, half + 1)) + result += (gaussian_binomial(length, rank) + * gaussian_binomial(rank, radical) * (gl_order // sp_order)) + return result + + +def check_projection(data): + class_counts = data["class_counts"] + elements = data["element_counts"] + rows = data["rows"] + require(len(class_counts) == len(elements) == 9 and len(rows) == N_CLASSES, "projection shape") + require(all(type(c) is int and 1 <= c <= N_CLASSES for c in class_counts), "class counts") + require(all(type(e) is int and 1 <= e <= ORDER for e in elements), "element counts") + require(sum(class_counts) == N_CLASSES and sum(elements) == ORDER, "class coverage") + require(class_counts[8] == elements[8] == 1, "single identity") + require(all(len(row) == 8 for row in rows), "projected row lengths") + for degree, *sums in rows: + require(type(degree) is int and 1 <= degree <= 68_850, "character degree") + require(all(type(s) is int and abs(s) <= degree * e + for s, e in zip(sums, elements[1:8], strict=True)), "character sum bounds") + + for length in range(9): + mass = sum(count * 2**(d * length) for d, count in enumerate(elements)) + require(mass == ORDER * tuple_orbits(length), "independent tuple orbit count") + + degrees = [row[0] for row in rows] + require(degrees[0] == 1 and sum(d * d for d in degrees) == ORDER, "degree square sum") + multiplicities = [] + for i, (degree, *sums) in enumerate(rows): + moment = degree * (2**32 - 1) + moment += sum(value * (2**(4*d) - 1) for d, value in enumerate(sums, 1)) + quotient, remainder = divmod(moment, ORDER) + require(remainder == 0 and quotient >= 0, "nonintegral or negative multiplicity") + multiplicities.append(quotient + (i == 0)) + require(sum(m * d for m, d in zip(multiplicities, degrees, strict=True)) == 2**32, + "multiplicity dimension sum") + require(sum(m * m for m in multiplicities) == tuple_orbits(8), "character norm") + return degrees, multiplicities + + +def require_rejected(data, reason): + try: + check_projection(data) + except ValueError as error: + require(str(error) == reason, f"unexpected control failure: {error}") + return + raise ValueError(f"control accepted: {reason}") + + +def check_controls(data): + rows = [row.copy() for row in data["rows"]] + rows[1][1] += 1 + require_rejected({**data, "rows": rows}, "nonintegral or negative multiplicity") + elements = data["element_counts"].copy() + elements[0] -= 1 + elements[1] += 1 + require_rejected({**data, "element_counts": elements}, "independent tuple orbit count") + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--ctbllib-archive", type=Path, help="optional CTblLib 1.3.11 release archive") + args = parser.parse_args() + data = json.loads(read_bounded(Path(__file__).with_name("PROJECTION.json"), 64 * 1024)) + if args.ctbllib_archive is not None: + require(table_projection(read_table(args.ctbllib_archive)) == data, "source projection differs") + print("PASS_CTBL_SOURCE_PROJECTION classes=81 rows=81") + degrees, multiplicities = check_projection(data) + check_controls(data) + missing = [i for i, m in enumerate(multiplicities, 1) if m == 0] + require(missing == MISSING_ROWS, "missing character row indices") + nullity = 256 * sum(degrees[i - 1]**2 for i in missing) + rank = 256 * ORDER - nullity + require((rank, nullity) == (10_107_260_791_808, 2_021_408_084_992), "Gram dimension result") + print(f"PASS_CLIFFORD_FOUR_QUBIT_WIDTH_NINE classes={N_CLASSES} " + f"present={N_CLASSES - len(missing)} missing={len(missing)} rank={rank} nullity={nullity} " + "tuple_moments=9 controls=2") + + +if __name__ == "__main__": + main() diff --git a/research/clifford-four-qubit-threshold/retained/three-qubit-PROOF.md b/research/clifford-four-qubit-threshold/retained/three-qubit-PROOF.md new file mode 100644 index 0000000000..9f89ee36a0 --- /dev/null +++ b/research/clifford-four-qubit-threshold/retained/three-qubit-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-four-qubit-threshold/verify.py b/research/clifford-four-qubit-threshold/verify.py new file mode 100644 index 0000000000..ccdf8a4e71 --- /dev/null +++ b/research/clifford-four-qubit-threshold/verify.py @@ -0,0 +1,437 @@ +#!/usr/bin/env python3 +"""Check the binary geometry and literal Pauli conventions of the missing block.""" +import argparse +from collections import Counter, deque +from hashlib import sha1, sha256 +from itertools import combinations, product +import json +from math import prod +from pathlib import Path +import subprocess +import sys + +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def parity(value): + return value.bit_count() & 1 + + +def omega(x, y, n): + mask = (1 << n) - 1 + return parity((x & mask) & (y >> n)) ^ parity((y & mask) & (x >> n)) + + +def quadratic(x, n, minus=True): + value = parity((x & ((1 << n) - 1)) & (x >> n)) + return value ^ ((x & 1) ^ ((x >> n) & 1) if minus else 0) + + +def reduced(rows): + basis = {} + for row in rows: + for pivot in sorted(basis, reverse=True): + if row >> pivot & 1: + row ^= basis[pivot] + if row: + pivot = row.bit_length() - 1 + for old in basis: + if basis[old] >> pivot & 1: + basis[old] ^= row + basis[pivot] = row + return tuple(basis[p] for p in sorted(basis, reverse=True)) + + +def rank(rows): + return len(reduced(rows)) + + +def span(basis): + values = [0] + for row in basis: + values += [v ^ row for v in values] + return values + + +def subspaces(width, dimension): + """Generate each binary row-reduced basis once, with increasing pivots.""" + for pivots in combinations(range(width), dimension): + free = [(i, j) for i, p in enumerate(pivots) + for j in range(p + 1, width) if j not in pivots] + for bits in range(1 << len(free)): + basis = [1 << p for p in pivots] + for bit, (i, j) in enumerate(free): + if bits >> bit & 1: + basis[i] |= 1 << j + yield tuple(basis) + + +def geometry(): + q = [quadratic(v, 4) for v in range(256)] + require(Counter(q) == {0: 120, 1: 136}, 'minus zero count') + histogram = Counter() + chosen = Counter() + for basis in subspaces(8, 4): + vectors = span(basis) + nonsingular = [v for v in vectors if q[v]] + require(nonsingular, 'singular four-space') + histogram[len(nonsingular)] += 1 + v = min(nonsingular) + chosen[v] += 1 + equations = reduced([(b >> 4) | ((b & 15) << 4) for b in basis]) + pivots = {r.bit_length() - 1 for r in equations} + perpendicular = [] + for free in range(8): + if free not in pivots: + u = 1 << free + for row in equations: + if parity(row & u): + u ^= 1 << (row.bit_length() - 1) + perpendicular.append(u) + require(len(perpendicular) == 4 and all(not omega(u, v, 4) for u in perpendicular), + 'complement witness') + expected_count = prod(256 - 2**i for i in range(4)) // prod(16 - 2**i for i in range(4)) + require(sum(histogram.values()) == expected_count == 200787, 'complete four-space count') + # This second enumeration extends only singular spaces and deduplicates their bases. + spaces = {()} + singular_counts = [1] + for dimension in range(1, 5): + next_spaces = set() + for basis in spaces: + current = set(span(basis)) + for v in range(1, 256): + if v not in current and not q[v] and all(not omega(v, b, 4) for b in basis): + next_spaces.add(reduced((*basis, v))) + spaces = next_spaces + singular_counts.append(len(spaces)) + require(singular_counts == [1, 119, 1071, 765, 0], 'independent singular-space census') + # A plus-type space does have a singular four-space; it must fail the witness test. + plus_lagrangian = [1 << i for i in range(4)] + require(all(quadratic(v, 4, False) == 0 for v in span(plus_lagrangian)), 'plus control') + # Five tuple vectors can also have a singular orthogonal complement in minus type. + singular_three = (2, 4, 8) + complement = [v for v in range(256) if all(not omega(v, b, 4) for b in singular_three)] + require(rank(complement) == 5 and all(q[v] == 0 for v in span(singular_three)), + 'five-tuple control') + return {'four_spaces': expected_count, 'nonsingular_histogram': {str(k): v for k, v in sorted(histogram.items())}, + 'singular_space_counts': singular_counts, 'chosen_transvections': len(chosen)} + + +def apply(matrix, vector): + value = 0 + while vector: + bit = (vector & -vector).bit_length() - 1 + value ^= matrix[bit] + vector &= vector - 1 + return value + + +def compose(left, right): + return tuple(apply(left, col) for col in right) + + +def transvection(vector, n): + return tuple((1 << i) ^ (vector if omega(1 << i, vector, n) else 0) for i in range(2*n)) + + +def dickson(matrix): + return rank([value ^ (1 << i) for i, value in enumerate(matrix)]) & 1 + + +def sign_checks(): + generators = [transvection(v, 4) for v in range(1, 256) if quadratic(v, 4)] + for matrix in generators: + require(dickson(matrix) == 1, 'transvection sign') + require(all(quadratic(apply(matrix, x), 4) == quadratic(x, 4) for x in range(256)), + 'transvection isometry') + for a, b in product(generators, repeat=2): + require(dickson(compose(a, b)) == 0, 'two-transvection sign') + # Enumerate the complete minus group in dimension four as a separate character check. + small_generators = [transvection(v, 2) for v in range(1, 16) if quadratic(v, 2)] + identity = tuple(1 << i for i in range(4)) + group = {identity} + queue = deque([identity]) + while queue: + old = queue.popleft() + for generator in small_generators: + new = compose(generator, old) + if new not in group: + group.add(new) + queue.append(new) + require(len(group) == 120, 'small orthogonal group order') + for a, b in product(group, repeat=2): + require(dickson(compose(a, b)) == (dickson(a) ^ dickson(b)), 'small full sign law') + moments = [] + for length in range(5): + mass = sum((-1)**dickson(g) * (1 << (4 - rank([g[i] ^ (1 << i) for i in range(4)])))**length + for g in group) + require(mass % 120 == 0 and mass >= 0, 'sign multiplicity') + moments.append(mass // 120) + require(moments[:3] == [0, 0, 0] and moments[3] > 0, 'tuple threshold control') + return {'transvections': len(generators), 'isometry_points': 256 * len(generators), + 'transvection_pairs': len(generators)**2, 'small_group_order': len(group), + 'small_group_pairs': len(group)**2, 'small_sign_multiplicities': moments} + + +def pauli(label, x, n): + a = label & ((1 << n) - 1) + b = label >> n + return x ^ a, ((a & b).bit_count() + 2 * parity(b & x)) % 4 + + +def bell(label, n): + return {(x, pauli(label, x, n)[0]): pauli(label, x, n)[1] for x in range(1 << n)} + + +UNITS = ((1, 0), (0, 1), (-1, 0), (0, -1)) + + +def gate_action(kind, i, j, x): + if kind == 'S': + return [(x, (x >> i) & 1)] + if kind == 'CNOT': + return [(x ^ ((1 << j) if x >> i & 1 else 0), 0)] + # The Gaussian Hadamard is (1+i)/2 times the integer Hadamard. + return [(x & ~(1 << i), 0), (x | (1 << i), 2 if x >> i & 1 else 0)] + + +def bell_checks(): + n = 4 + vectors = [bell(t, n) for t in range(256)] + for label, vector in enumerate(vectors): + for v in range(256): + output = {} + for (x, y), phase in vector.items(): + xx, px = pauli(v, x, n) + yy, py = pauli(v, y, n) + output[xx, yy] = (phase + px + py) % 4 + expected = (quadratic(v, n, False) ^ omega(v, label, n)) * 2 + require(output == {key: (phase + expected) % 4 for key, phase in vector.items()}, + 'literal Pauli character') + norms = Counter() + for a, b in product(range(256), repeat=2): + real = imag = 0 + for key, phase in vectors[a].items(): + if key in vectors[b]: + x, y = UNITS[(vectors[b][key] - phase) % 4] + real += x + imag += y + require((real, imag) == ((16, 0) if a == b else (0, 0)), 'Bell basis orthogonality') + for label, vector in enumerate(vectors): + swap = {(y, x): p for (x, y), p in vector.items()} + sign = 2 * quadratic(label, n, False) + require(swap == {key: (p + sign) % 4 for key, p in vector.items()}, 'Bell exchange sign') + norms[sign] += 1 + require(dict(norms) == {0: 136, 2: 120}, 'quadratic orbit dimensions') + lookup = {} + for t, vector in enumerate(vectors): + first = vector[min(vector)] + lookup[tuple((key, (p-first) % 4) for key, p in sorted(vector.items()))] = t + generators = [('S', i, 0) for i in range(4)] + [('H', i, 0) for i in range(4)] + generators += [('CNOT', i, j) for i in range(4) for j in range(4) if i != j] + permutations = [] + character_controls = Counter() + for kind, i, j in generators: + permutation = [] + wedge_real = wedge_imag = 0 + for label, vector in enumerate(vectors): + output = {} + for (x, y), phase in vector.items(): + for (xx, px), (yy, py) in product(gate_action(kind, i, j, x), gate_action(kind, i, j, y)): + # Two Hadamard prefactors multiply to i/2. + value = UNITS[(phase + px + py + (kind == 'H')) % 4] + old = output.get((xx, yy), (0, 0)) + output[xx, yy] = (old[0] + value[0], old[1] + value[1]) + output = {key: value for key, value in output.items() if value != (0, 0)} + phases = {} + divisor = 2 if kind == 'H' else 1 + for key, (real, imag) in output.items(): + require(real % divisor == imag % divisor == 0, 'Hadamard integral phase') + value = (real // divisor, imag // divisor) + require(value in UNITS, 'Bell monomial coefficient') + phases[key] = UNITS.index(value) + first = phases[min(phases)] + key = tuple((position, (p-first) % 4) for position, p in sorted(phases.items())) + require(key in lookup, 'Bell generator image') + target = lookup[key] + require(quadratic(target, n, False) == quadratic(label, n, False), 'Arf preservation') + permutation.append(target) + if target == label and quadratic(label, n, False): + real, imag = UNITS[(first - vector[min(vector)]) % 4] + wedge_real += real + wedge_imag += imag + require(len(set(permutation)) == 256, 'Bell permutation') + permutations.append(permutation) + linear = tuple(permutation[1 << i] ^ permutation[0] for i in range(8)) + require(all(permutation[t] == (apply(linear, t) ^ permutation[0]) for t in range(256)), + 'affine quadratic action') + maps = [dict(gate_action(kind, i, j, x)) for x in range(16)] + minor_real = minor_imag = 0 + for x, y in combinations(range(16), 2): + for first_input, second_input, sign in [(x, y, 1), (y, x, -1)]: + if x in maps[first_input] and y in maps[second_input]: + phase = maps[first_input][x] + maps[second_input][y] + (kind == 'H') + real, imag = UNITS[phase % 4] + minor_real += sign * real + minor_imag += sign * imag + divisor = 2 if kind == 'H' else 1 + require((minor_real, minor_imag) == (divisor*wedge_real, divisor*wedge_imag), + 'literal exterior-square character') + sign = (-1)**dickson(linear) + character_controls[(kind, wedge_real, wedge_imag, sign*wedge_real, sign*wedge_imag)] += 1 + unseen = set(range(256)) + orbits = [] + while unseen: + start = min(unseen) + found = {start} + queue = deque([start]) + while queue: + t = queue.popleft() + for permutation in permutations: + new = permutation[t] + if new not in found: + found.add(new) + queue.append(new) + unseen -= found + orbits.append(len(found)) + require(sorted(orbits) == [120, 136], 'actual gate quadratic orbits') + require(dict(character_controls) == {('S', 0, 64, 0, -64): 4, + ('H', 0, -8, 0, 8): 4, + ('CNOT', 24, 0, 24, 0): 12}, 'explicit character controls') + return {'character_controls': [[*key, value] for key, value in sorted(character_controls.items())], + 'pauli_character_pairs': 65536, 'bell_inner_products': 65536, + 'literal_clifford_generators': 20, 'literal_bell_images': 5120, 'orbits': sorted(orbits)} + + +def signed_quotient_check(): + data = json.loads((ROOT / 'retained/source7747/PROJECTION.json').read_text()) + order = sum(data['element_counts']) + output = [] + for index, orbit_size in [(4, 120), (5, 136)]: + row = data['rows'][index] + require(row[0] + 1 == orbit_size, 'quadratic permutation degree') + sums = [0] + row[1:] + [row[0]] + sums[0] = -sum(sums) + fixed_masses = [count + value for count, value in + zip(data['element_counts'], sums, strict=True)] + terms = [(-1)**d * value * 2**(4*d) for d, value in enumerate(fixed_masses)] + numerator = sum(terms) + require(numerator % order == 0, 'signed quotient integrality') + unsigned = sum(value * 2**(4*d) for d, value in enumerate(fixed_masses)) + require(unsigned % order == 0 and unsigned > 0, 'omitted sign control') + output.append(dict(orbit_size=orbit_size, signed_terms=terms, + multiplicity=numerator//order, unsigned_multiplicity=unsigned//order)) + require([r['multiplicity'] for r in output] == [0, 1], 'two exact stabilizer multiplicities') + return output + + +def gaussian_binomial(n, r): + return prod(2**n - 2**i for i in range(r)) // prod(2**r - 2**i for i in range(r)) + + +def tuple_orbits(length): + total = 0 + for r in range(min(length, 8) + 1): + for radical in range(r % 2, r + 1, 2): + if r + radical > 8: + continue + even = r - radical + gl = prod(2**even - 2**i for i in range(even)) + half = even // 2 + symplectic = 2**(half*half) * prod(2**(2*i)-1 for i in range(1, half+1)) + total += gaussian_binomial(length, r) * gaussian_binomial(r, radical) * (gl//symplectic) + return total + + +def odd_multiplicities(data, power): + order = sum(data['element_counts']) + values = [] + for index, row in enumerate(data['rows']): + degree = row[0] + numerator = degree*(2**(8*power)-1) + numerator += sum(value*((-1)**d * 2**(power*d)-1) for d, value in enumerate(row[1:], 1)) + quotient, remainder = divmod(numerator, order) + require(remainder == 0 and quotient >= 0, 'odd multiplicity integrality') + values.append(quotient + (index == 0)) + sums = [0] + row[1:] + [degree] + sums[0] = (order if index == 0 else 0) - sum(sums) + direct = sum(value*(-1)**d * 2**(power*d) for d, value in enumerate(sums)) + require(direct == order*values[-1], 'direct bin character sum') + require(sum(m*r[0] for m, r in zip(values, data['rows'], strict=True)) == 2**(8*power), + 'odd multiplicity dimension') + norm = tuple_orbits(2*power) + require(sum(m*m for m in values) == norm, 'independent long-tuple norm') + require(sum(count*2**(2*power*d) for d, count in enumerate(data['element_counts'])) == order*norm, + 'long-tuple histogram moment') + return values, norm + + +def threshold_check(): + data = json.loads((ROOT/'retained/source7747/PROJECTION.json').read_text()) + order = sum(data['element_counts']) + m11, norm11 = odd_multiplicities(data, 5) + m13, norm13 = odd_multiplicities(data, 6) + missing = [i+1 for i, m in enumerate(m11) if m == 0] + require(missing == [9, 22] and [data['rows'][i-1][0] for i in missing] == [595, 3213], + 'width eleven support') + require(all(m > 0 for m in m13), 'width thirteen support') + loss = sum(data['rows'][i-1][0]**2 for i in missing) + require(loss == 10677394, 'inflated block dimensions') + bad = json.loads(json.dumps(data)) + bad['rows'][8][1] += 1 + try: + odd_multiplicities(bad, 5) + except ValueError as error: + require(str(error) == 'odd multiplicity integrality', 'wrong character fault') + else: + raise ValueError('changed character sum passed') + return dict(width11_multiplicities=m11, width13_multiplicities=m13, + width11_missing_rows=missing, width11_missing_quotient_degrees=[595, 3213], + width11_nullity=256*loss, width11_rank=256*order-256*loss, + width12_nullity_lower=loss, width12_rank_upper=256*order-loss, + width13_rank=256*order, threshold=13, + quotient_norms=[norm11, norm13], minimum_width13_multiplicity=min(m13)) + + +def verify(args): + pins = json.loads((ROOT / 'SOURCE-PINS.json').read_text())['sources'] + for pin in pins: + raw = (ROOT / pin['retained']).read_bytes() + require(sha256(raw).hexdigest() == pin['sha256'] and + sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], 'source pin') + result = {'geometry': geometry(), 'sign': sign_checks(), 'literal_bell': bell_checks(), + 'quotient_check': signed_quotient_check(), 'threshold': threshold_check()} + order = 4**4 * 2**16 * prod(2**(2*i)-1 for i in range(1, 5)) + missing = 2**3 * (2**4-1) + require((order, missing, missing**2) == (12128668876800, 120, 14400), 'four-qubit block dimensions') + result['four_qubit'] = dict(projective_order=order, missing_block_degree=missing, + nullity_lower=missing**2, rank_upper=order-missing**2, threshold_lower=11) + if args.collect: + print(json.dumps(result, indent=2)) + return + require(result == json.loads((ROOT / 'RESULT.json').read_text()), 'result certificate') + mode = ['-O'] if sys.flags.optimize else [] + old = subprocess.run([sys.executable, '-W', 'error', *mode, '-B', + str(ROOT/'retained/source7747/verify.py'), + *(['--ctbllib-archive', str(args.ctbllib_archive)] if args.ctbllib_archive else [])], capture_output=True, text=True, timeout=30) + require(old.returncode == 0 and 'PASS_CLIFFORD_FOUR_QUBIT_WIDTH_NINE' in old.stdout, 'source replay') + print('PASS_CLIFFORD_FOUR_QUBIT_THRESHOLD') + print('Sharp threshold T(4)=13; width eleven nullity 2733412864; width twelve nullity >= 10677394') + print('Width thirteen: all 81 quotient rows occur; full Gram rank 12128668876800') + print('Four qubits at width ten: absent degree 120, nullity >= 14400, T(4) >= 11') + print('200787 four-spaces; independent singular-space census 1,119,1071,765,0') + print('65536 Pauli characters; 65536 Bell inner products; 5120 literal Clifford Bell images') + print('Independent signed quotient sums: minus multiplicity 0, plus multiplicity 1') + print('Written extension: T(n) >= 2n+3 for every positive n divisible by four') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--collect', action='store_true', help='Print the exact certificate') + parser.add_argument('--ctbllib-archive', type=Path, help='Rebuild the retained projection from CTblLib 1.3.11') + verify(parser.parse_args())