diff --git a/research/clifford-width-ten-nullity/CREDITS.md b/research/clifford-width-ten-nullity/CREDITS.md new file mode 100644 index 0000000000..08ce5fd66a --- /dev/null +++ b/research/clifford-width-ten-nullity/CREDITS.md @@ -0,0 +1,48 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared the new full sector calculation, +exact extractor, checker and package with substantial OpenAI Codex +assistance. New material is Apache-2.0. No independent human or +formal proof-kernel acceptance is claimed. + +Nick Petalas (@petalas) supplied the +[width-nine quotient and question](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/README.md), +[81-row projection](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/PROJECTION.json) +and [archive reader and table parser](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/verify.py) +in [PR #7747](https://github.com/CrocSwap/integer-mult-bounds/pull/7747). +The new extractor follows its MOT record selection and published row +order, then adds the complete ordinary orthogonal tables, class +fusions, tensor rows and exact Galois arithmetic. + +Ali Romman's [PR #7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766) +supplied the [actual Bell-line extension and Dickson obstruction](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/PROOF.md) +and [literal gate and Pauli routines](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/verify.py). +All eighteen package files remain byte-exact and its complete verifier +runs unchanged. Its source closure retains Nick's six-file package +and alephnan's proof. + +Ali Romman's [PR #7770](https://github.com/CrocSwap/integer-mult-bounds/pull/7770) +supplied the [restriction argument and remaining width-ten question](https://github.com/aliromman/integer-mult-bounds/blob/ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2/research/clifford-width-twelve-nullity/PROOF.md) +and [all symplectic class columns used to check the fusions](https://github.com/aliromman/integer-mult-bounds/blob/ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2/research/clifford-width-twelve-nullity/CHARACTER-COLUMNS.json). +Five notes and data files are retained. Its full width-twelve suite +is not rerun as part of this package. + +alephnan (@alephnan) supplied the +[Pauli/quadratic-sector framework](https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md) +in [PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714), +with the stated OpenAI Codex assistance. All earlier notices and +credit remain intact. The full three-qubit suite is not rerun. + +The ordinary tables and class fusions credit the ATLAS and +[Thomas Breuer's CTblLib 1.3.11](https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/ctbllib-1.3.11.tar.gz). +The complete ordinary tables are external mathematical inputs; +`STABILIZERS.json` retains derived sums and restriction coefficients. +The exact archive and three member hashes are in `EXTERNAL.json`. +The independent tuple count uses +[D. E. Taylor's Witt extension theorem, Theorem 7.4](https://www.maths.usyd.edu.au/u/don/papers/gcg.pdf#page=65). +Character induction, reciprocity and quadratic-space theory are +classical inputs, not claimed as new general theory. + +Source commits are content pins, not ancestry claims. `SOURCES.json` +records canonical main provenance, and `SOURCE-PINS.json` authenticates +all twenty-three retained files. No global literature priority is claimed. diff --git a/research/clifford-width-ten-nullity/EXTERNAL.json b/research/clifford-width-ten-nullity/EXTERNAL.json new file mode 100644 index 0000000000..f9bf4e0be0 --- /dev/null +++ b/research/clifford-width-ten-nullity/EXTERNAL.json @@ -0,0 +1,25 @@ +{ + "author": "ATLAS contributors; Thomas Breuer and CTblLib contributors", + "title": "CTblLib 1.3.11: S8(2), O8-(2).2, O8+(2).2 and their class fusions", + "archive_url": "https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/ctbllib-1.3.11.tar.gz", + "archive_sha256": "f201e9da571c681a7bbfb1e4683bdb2c80a23b005099ed0453521f59cb443434", + "members": { + "ctbllib-1.3.11/data/ctosymp1.tbl": "461519e33cb31b2bc46f554b09f283f0afb7125fd805840d79bfc614fce75b6f", + "ctbllib-1.3.11/data/ctoorth2.tbl": "cf250c9b4ada37a8c8e5fc93570ba3c24c9cd9197baf8a646e568194de2afdce", + "ctbllib-1.3.11/data/ctoorth3.tbl": "736b8f34211dd8a20c51312015fa72c1bb0a4931db19b317ea436ac0e9644626" + }, + "used": "All ordinary characters and the two form-stabilizer class fusions; derived rational projections and restriction coefficients.", + "verification": "Archive and all three members authenticated. Full row orthogonality, exact Galois/tensor rows and both complete restrictions are recomputed. No group-multiplication reconstruction is claimed.", + "derived_file": "STABILIZERS.json", + "derived_sha256": "6c7cea6d3fa3236dfae831b329fdb8c67db4fcae54dae8dea1242ee8f9bb5c2c", + "independent_orbit_reference": { + "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=65", + "theorem": "7.4 (Witt)", + "printed_page": 57, + "pdf_page": 65, + "used": "An isometry between tuple images extends because the ambient polar form has zero radical." + } +} diff --git a/research/clifford-width-ten-nullity/PROOF.md b/research/clifford-width-ten-nullity/PROOF.md new file mode 100644 index 0000000000..7c1c0713d1 --- /dev/null +++ b/research/clifford-width-ten-nullity/PROOF.md @@ -0,0 +1,237 @@ +# The full four-qubit width-ten nullity + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Use the full Gaussian-dyadic four-qubit Clifford group G, natural +representation V of dimension sixteen, Pauli subgroup P and scalar +kernel Z of order four from +[PR #7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766). +Write S=G/P=Sp(8,2) and N=|G/Z|=12,128,668,876,800. +The projective Gram matrix at tensor width ten has + +```text +exact nullity = 193,919,902,208, +exact rank = 11,934,748,974,592. +``` + +There are fifteen absent irreducible modules: seven from the minus +quadratic orbit and eight from the plus orbit. Their full list is below. +This resolves the width-ten question left by +[PR #7770](https://github.com/CrocSwap/integer-mult-bounds/pull/7770). +The threshold T(4)=13 is unchanged. No physical supplier or new kappa +follows. + +## 1. The actual modules use Bell-line extensions + +The [source quotient calculation](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/README.md) +gives V^9=V tensor W9, where W9 is an honest S module of dimension +2^32. If s fixes a d-dimensional subspace in the natural binary +space E, its character is 2^(4d). Thus W9 is the permutation module +on four ordered vectors of E. Its complete 81-row decomposition has +twenty absent rows and is replayed unchanged. + +At width ten, + +```text +V^(tensor 10) = (V tensor V) tensor W9. +``` + +The Pauli weight lines in V tensor V are indexed by the 256 quadratic +refinements q of the symplectic form on E. The two S orbits have sizes +120 and 136. Their stabilizers are the full orthogonal groups H_minus +and H_plus, of orders 394,813,440 and 348,364,800. The CTblLib records +for these groups are named `O8-(2).2` and `O8+(2).2`. + +For each q, let T_q be the preimage of H_q in G. The actual Bell line +has a one-dimensional T_q character eta_q extending its P character. +This is the extension constructed in the +[pinned source proof, Sections 2 and 4](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/PROOF.md). +Its signs and Gaussian phases are part of the representation. + +For each ordinary irreducible H_q module rho, define + +```text +pi_(q,rho) = Ind_(T_q)^G(eta_q tensor rho). +``` + +These are exactly the irreducible G modules in the central-character +sector z -> -1. Each is irreducible because its distinct P weight +spaces form one orbit, and its stabilizer acts irreducibly on one +weight space. Conversely, divide one weight-space action by eta_q +to obtain an H_q irreducible, then induce. This argument needs no +splitting of the projective Clifford extension. + +The degree of pi is [S:H_q] dim(rho), and its multiplicity in V^10 is + +```text +m_rho = < Res_(H_q) W9, rho >. +``` + +The actual eta_q cancels on both sides of this weight-space comparison. +It is not an assumption that the Bell line is trivial. These two +families exhaust the central-character sector, since their squared +degrees sum to + +```text +120^2 |H_minus| + 136^2 |H_plus| = (120+136)|S| = N. +``` + +## 2. Authenticate the two complete restriction calculations + +The exact CTblLib 1.3.11 archive supplies the three ordinary tables +and both `ALF` class fusions into S8(2). `EXTERNAL.json` pins the archive +and the three table members by SHA-256. The published tables and +form-stabilizer fusions are mathematical inputs, not reconstructions +from group multiplication. + +The extractor reads all 81 S rows, 60 minus rows and 67 plus rows. +It expands every tensor row and every Galois row. All values lie in +the real quadratic field represented by (a+b t)/2 with t^2=17. +The checker derives t from the seventeenth-root quadratic period, +checks its square and conjugation, and checks that Galois power three +negates it. It does not copy a Galois row as if its entries were rational. +All 14,650 ordinary row inner products pass exactly. + +The fusion is checked against the actual quadratic-form permutation +characters. For every S class C, + +```text +Ind_(H_minus)^S(1)(C) = 1+chi_5(C), +Ind_(H_plus)^S(1)(C) = 1+chi_6(C), +``` + +where the degrees are 119 and 135. The class sizes and centralizers +in the fusion give the left sides. The pinned source gives the right +sides. The same fusion sends each stabilizer class to its natural +fixed-space dimension d. The second row of each full orthogonal +table is exactly the Dickson sign (-1)^d, which is another source +convention check. + +For an H row of degree e, let A_d sum |C| rho(C) over its classes with +fixed dimension d, for 1<=d<=7. The unique d=8 class is identity. +Subtracting the constant character removes d=0 classes and gives + +```text +m_rho = [rho is trivial] + + [e(2^32-1) + sum_(d=1)^7 A_d(2^(4d)-1)] / |H|. +``` + +Every result is an exact nonnegative integer. Independently, the +extractor computes all 10,287 coefficients in the restrictions of +the 81 S irreducibles to the 127 H irreducibles. Every coefficient is +an exact nonnegative integer. Combining them with the source W9 +multiplicities gives exactly the same 127 values. Both the restricted +and induced degree sums agree. + +The sparse restriction matrix and all projected rows are retained in +`STABILIZERS.json`. The optional archive command reconstructs this +entire file, including the complete ordinary inner-product and Galois +checks. Registered replay needs only the retained data; it repeats +both multiplicity formulas, fusion checks and independent orbit tests. + +## 3. The fifteen absent modules + +| Quadratic type | Stabilizer row | Stabilizer degree | Clifford degree | +| --- | --- | --- | --- | +| minus | 2 | 1 | 120 | +| minus | 4 | 34 | 4,080 | +| minus | 10 | 204 | 24,480 | +| minus | 14 | 357 | 42,840 | +| minus | 22 | 714 | 85,680 | +| minus | 28 | 1,071 | 128,520 | +| minus | 43 | 2,295 | 275,400 | +| plus | 4 | 28 | 3,808 | +| plus | 6 | 35 | 4,760 | +| plus | 14 | 175 | 23,800 | +| plus | 16 | 210 | 28,560 | +| plus | 21 | 350 | 47,600 | +| plus | 25 | 567 | 77,112 | +| plus | 44 | 1,400 | 190,400 | +| plus | 46 | 1,575 | 214,200 | + +The row numbers refer to the published ordinary stabilizer tables, +not to the S8(2) table. Every unlisted stabilizer row occurs. The first +minus row in the table above is the Dickson module already proved +absent by the source. The plus Dickson row has multiplicity one, +which agrees with the source's separate signed calculation. + +The two missing regular-block totals are + +```text +minus: 102,154,809,600, +plus: 91,765,092,608, +total: 193,919,902,208. +``` + +A degree-e irreducible contributes e^2 to the regular block. The +projective Gram matrix represents the central-character-minus-one +ideal; a block has positive eigenvalue exactly when its module occurs +in the tensor power. Thus the total is its full nullity, and subtraction +from N gives the stated exact rank. No other central-character blocks +belong to this Gram matrix. + +## 4. An independent quadratic-space count + +The character norm of W9 restricted to H equals the number of H orbits +on eight ordered vectors. This number can be counted without either +character table. More generally, encode a tuple of length k by a map +from F2^k to a quadratic space of dimension 2n. Let its image have +dimension r and its induced alternating form have radical dimension t. +The kernel has [k choose r]_2 choices. On the quotient, the number of +alternating forms of radical dimension t is + +```text +B(r,t) = [r choose t]_2 |GL(r-t,2)| / |Sp(r-t,2)|, +``` + +where r-t is even. If r+t>2n, no embedding exists. If r+t<2n, all 2^r +quadratic refinements embed. At equality, write r-t=2s and let epsilon +be +1 for plus type and -1 for minus type. The number that embed is + +```text +(2^t-1) 2^(2s) + Z_epsilon(2s), +Z_epsilon(2s) = (2^(2s)+epsilon 2^s)/2, s>0, +Z_plus(0)=1, Z_minus(0)=0. +``` + +Here is the embedding condition. If the quadratic form is nonzero on +the alternating radical, one nonsingular radical vector can be paired +with a dual vector whose value can change the ambient Arf type. Both +types are therefore possible. If the quadratic form is zero on the +radical, the dual pairs are hyperbolic. At equality no complement +remains, so the nondegenerate part must have the ambient type. Below +equality a positive even-dimensional complement can supply either +type. The counts Z_epsilon are the usual two Arf-type counts for a +fixed nondegenerate alternating form. + +Two tuples with the same kernel and induced quadratic form are related +by an ambient isometry. This follows from +[Taylor's Witt extension theorem, Theorem 7.4](https://www.maths.usyd.edu.au/u/don/papers/gcg.pdf#page=65); +the ambient polar radical is zero. Consequently the orbit count is +obtained by summing the displayed terms over r,t, multiplied by +[k choose r]_2 B(r,t). + +For n=4 and k=4 the counts are 2,294 and 2,295. For k=8 they are +78,491,573,017 and 84,713,186,558. These equal the two sums of squared +multiplicities. Separate class-histogram moments give the same values. +As a finite control, the checker enumerates all four orthogonal groups +in dimensions two and four, of orders 2, 6, 72 and 120. Their direct +Burnside counts agree with the formula for every tuple length zero +through eight. + +## Evidence and limits + +All twenty-three retained source files are authenticated. The unchanged +source verifier includes its literal Pauli/Bell actions and threshold +calculation. Changed fusion and projected-character controls fail for +the stated reasons. The archive replay also rejects a copied Galois +row. All registered, archive and source checks use exact arithmetic. + +The argument depends on the published ordinary tables and class +fusions. Their hashes, character identities, dimensions and independent +orbit counts were checked; no full four-qubit group or Gram matrix was +materialized. The full three-qubit suite, selected cold replay, Lean +and Docker were not run. Conditioning, native realization and complete +caller pricing remain open. T(4)=13, all five framework assumptions +and the selected frontier remain unchanged. No independent human, +formal-kernel acceptance or global literature priority is claimed. diff --git a/research/clifford-width-ten-nullity/README.md b/research/clifford-width-ten-nullity/README.md new file mode 100644 index 0000000000..b273d9448a --- /dev/null +++ b/research/clifford-width-ten-nullity/README.md @@ -0,0 +1,47 @@ +# Exact four-qubit width-ten nullity + +The full Gaussian-dyadic four-qubit Clifford Gram matrix at tensor +width ten has exact nullity 193,919,902,208 and exact rank +11,934,748,974,592. Seven minus-type and eight plus-type modules are +absent. Every other module in the required central-character sector +occurs. T(4)=13 is unchanged; no new kappa follows. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[STABILIZERS.json](STABILIZERS.json), [verify.py](verify.py), +[extract.py](extract.py), [SOURCE-PINS.json](SOURCE-PINS.json), +[EXTERNAL.json](EXTERNAL.json) and [CREDITS.md](CREDITS.md). + +Run with Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-width-ten-nullity +``` + +Both registered modes print `PASS_CLIFFORD_WIDTH_TEN_NULLITY`. +They use the retained projections and need no network access. +To reconstruct the complete data from the authenticated CTblLib +release in EXTERNAL.json, also run: + +```sh +python3.12 -B research/clifford-width-ten-nullity/verify.py \ + --ctbllib-archive /path/to/ctbllib-1.3.11.tar.gz +``` + +This command also prints +`PASS_AUTHENTICATED_STABILIZERS rows=127 inner_products=14650 restrictions=10287`. +It checks the full ordinary character rows, Galois action and class +fusions before comparison with every retained projection and sparse +restriction coefficient. The published tables remain mathematical +inputs; these checks do not rebuild them from group multiplication. + +## Open next questions + +- Determine exact spectral endpoints at the first independent width. + Start with all required block eigenvalues; full support alone does + not give conditioning. +- Determine which parts of the stabilizer calculation extend to more + qubits without a full ordinary character table. +- Connect the alphabet to native realization and complete caller + costs. The present algebraic result supplies no physical supplier. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/clifford-width-ten-nullity/RESULT.json b/research/clifford-width-ten-nullity/RESULT.json new file mode 100644 index 0000000000..592a637551 --- /dev/null +++ b/research/clifford-width-ten-nullity/RESULT.json @@ -0,0 +1,329 @@ +{ + "source_files": 23, + "groups": [ + { + "kind": "minus", + "index": 120, + "order": 394813440, + "multiplicities": [ + 2294, + 0, + 11220, + 0, + 11475, + 85, + 22815, + 35, + 20400, + 0, + 5355, + 2907, + 24990, + 0, + 25585, + 1785, + 39270, + 238, + 8925, + 2975, + 49980, + 0, + 26775, + 5355, + 52275, + 2295, + 32130, + 0, + 48195, + 3213, + 16065, + 17850, + 5950, + 81480, + 1512, + 37485, + 1785, + 48195, + 32130, + 41480, + 14280, + 68850, + 0, + 34425, + 42525, + 42525, + 74970, + 3570, + 41055, + 26775, + 67320, + 10200, + 96000, + 8960, + 80325, + 16065, + 71400, + 23800, + 80325, + 26775 + ], + "missing": [ + { + "row": 2, + "degree": 1, + "clifford_degree": 120 + }, + { + "row": 4, + "degree": 34, + "clifford_degree": 4080 + }, + { + "row": 10, + "degree": 204, + "clifford_degree": 24480 + }, + { + "row": 14, + "degree": 357, + "clifford_degree": 42840 + }, + { + "row": 22, + "degree": 714, + "clifford_degree": 85680 + }, + { + "row": 28, + "degree": 1071, + "clifford_degree": 128520 + }, + { + "row": 43, + "degree": 2295, + "clifford_degree": 275400 + } + ], + "nullity": 102154809600, + "tuple_norm": 78491573017, + "four_tuple_orbits": 2294, + "class_dimension_counts": { + "0": 5, + "1": 11, + "2": 15, + "3": 11, + "4": 9, + "5": 4, + "6": 3, + "7": 1, + "8": 1 + } + }, + { + "kind": "plus", + "index": 136, + "order": 348364800, + "multiplicities": [ + 2295, + 1, + 3808, + 0, + 11390, + 0, + 595, + 11475, + 255, + 22899, + 119, + 5355, + 5950, + 0, + 21420, + 0, + 3570, + 22950, + 510, + 11900, + 0, + 26775, + 1785, + 44982, + 0, + 9639, + 26775, + 7735, + 50575, + 595, + 11900, + 19635, + 5355, + 14280, + 47277, + 6885, + 53550, + 3570, + 26775, + 82824, + 2856, + 37128, + 47600, + 0, + 53550, + 0, + 26775, + 44625, + 8925, + 53550, + 61880, + 4760, + 38080, + 67473, + 3213, + 38556, + 48195, + 16065, + 48195, + 57800, + 30600, + 100096, + 13056, + 89250, + 17850, + 103275, + 34425 + ], + "missing": [ + { + "row": 4, + "degree": 28, + "clifford_degree": 3808 + }, + { + "row": 6, + "degree": 35, + "clifford_degree": 4760 + }, + { + "row": 14, + "degree": 175, + "clifford_degree": 23800 + }, + { + "row": 16, + "degree": 210, + "clifford_degree": 28560 + }, + { + "row": 21, + "degree": 350, + "clifford_degree": 47600 + }, + { + "row": 25, + "degree": 567, + "clifford_degree": 77112 + }, + { + "row": 44, + "degree": 1400, + "clifford_degree": 190400 + }, + { + "row": 46, + "degree": 1575, + "clifford_degree": 214200 + } + ], + "nullity": 91765092608, + "tuple_norm": 84713186558, + "four_tuple_orbits": 2295, + "class_dimension_counts": { + "0": 9, + "1": 11, + "2": 17, + "3": 11, + "4": 10, + "5": 4, + "6": 3, + "7": 1, + "8": 1 + } + } + ], + "small_group_checks": [ + { + "half_dimension": 1, + "minus": false, + "group_order": 2, + "tuple_orbits_0_to8": [ + 1, + 3, + 10, + 36, + 136, + 528, + 2080, + 8256, + 32896 + ] + }, + { + "half_dimension": 1, + "minus": true, + "group_order": 6, + "tuple_orbits_0_to8": [ + 1, + 2, + 5, + 15, + 51, + 187, + 715, + 2795, + 11051 + ] + }, + { + "half_dimension": 2, + "minus": false, + "group_order": 72, + "tuple_orbits_0_to8": [ + 1, + 3, + 15, + 120, + 1326, + 17578, + 255970, + 3907410, + 61067826 + ] + }, + { + "half_dimension": 2, + "minus": true, + "group_order": 120, + "tuple_orbits_0_to8": [ + 1, + 3, + 14, + 99, + 969, + 11781, + 162877, + 2416557, + 37208717 + ] + } + ], + "projective_order": 12128668876800, + "exact_nullity": 193919902208, + "exact_rank": 11934748974592, + "archive_validation_scope": { + "ordinary_inner_products": 14650, + "restriction_coefficients": 10287, + "omitted_galois_action_rejected": true, + "quadratic_period": "t^2=17; conjugation fixes t; Galois(3) negates t" + }, + "threshold": "T(4)=13 unchanged" +} diff --git a/research/clifford-width-ten-nullity/SOURCE-PINS.json b/research/clifford-width-ten-nullity/SOURCE-PINS.json new file mode 100644 index 0000000000..472038fe11 --- /dev/null +++ b/research/clifford-width-ten-nullity/SOURCE-PINS.json @@ -0,0 +1,189 @@ +{ + "schema_version": 1, + "sources": [ + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/.gitattributes", + "retained": "retained/source7766/.gitattributes", + "git_blob": "130a3ecaa26bd4a35622a8c5c22f05f14cc4c665", + "sha256": "3a90a01036aab114f09495dd88d8cc7db233e784ba70377064f11ffa8a1602fd" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/CREDITS.md", + "retained": "retained/source7766/CREDITS.md", + "git_blob": "db097954098a460d443aff29e0fca7aa0f656f85", + "sha256": "298c55f78f34e68c92072fffe5b4584a927f1dfeeb31f7aa69ce0bfc6439d58d" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/EXTERNAL.json", + "retained": "retained/source7766/EXTERNAL.json", + "git_blob": "26f473de7332d48eb558e2c1e6d7e8974108733d", + "sha256": "f585532da5ef912f4f2b5ef86c2b2ee6bdc267fdbe35faa2125af22d44e337fe" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/PROOF.md", + "retained": "retained/source7766/PROOF.md", + "git_blob": "d4fa0b807b36c265de73a6180dc54664a1a4a3d9", + "sha256": "55d166ea7a7f9cfa308a38a1315116820fbf4d94dd65e173b470a5b4449f2c2a" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/README.md", + "retained": "retained/source7766/README.md", + "git_blob": "72e1681213a9381fc5f0cb2cca1fef1a32dac5e7", + "sha256": "85d8d141e6825bb354006dec505cac83a65f7bdb2cc2a1463dbafcfe41f7e49b" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/RESULT.json", + "retained": "retained/source7766/RESULT.json", + "git_blob": "bbd3a1de1dfb82cb8f218f0c5cb7232f494a3365", + "sha256": "5cc14361a3c4be0ff1c2334e2d826a04616049057ba4e17190c2d06e5a1d1fa1" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/SOURCE-PINS.json", + "retained": "retained/source7766/SOURCE-PINS.json", + "git_blob": "6a30697ddef05b361fab234b3a1bc9542fb5beda", + "sha256": "0b6a8014097f088a2da0bb521ed3acba05cd08aa650711b8069a95ba221bce67" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/SOURCES.json", + "retained": "retained/source7766/SOURCES.json", + "git_blob": "5335fa97d97f6df5a917eea1ee2fcd01c082d261", + "sha256": "0761fd793723c2df1e2ca51733251cfd597ff3e120f7e2ee8ebb8e10e8e98c08" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/TASK.json", + "retained": "retained/source7766/TASK.json", + "git_blob": "8899527d79f8a09ddb7fa840e5337e97fa4b2034", + "sha256": "540fed15dc4391a436ea68f6f29842eaa655582f72f2b388bfb53796bacebbf4" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/VERIFY.json", + "retained": "retained/source7766/VERIFY.json", + "git_blob": "5ddaf52c4c580451bdd1a6c9b99c9a2d014e46d4", + "sha256": "a609aa8e551af5bdd850b70352f03ce651eb93558f01011eeff6530cdd91581d" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/source7747/PROJECTION.json", + "retained": "retained/source7766/retained/source7747/PROJECTION.json", + "git_blob": "406f84b46901df771050eac3f367413cc6529ba1", + "sha256": "0a36754668b66480e5f968c117a4532bc3a5eaab5c9d8448f14a5d0321c2efae" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/source7747/README.md", + "retained": "retained/source7766/retained/source7747/README.md", + "git_blob": "d31d4d24c9f5ad26d26ccfd1a01f8754e81a6241", + "sha256": "7e841784df881cda0215da6bb005c80d050659a2f33f56e923509994b50ea6b7" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/source7747/SOURCES.json", + "retained": "retained/source7766/retained/source7747/SOURCES.json", + "git_blob": "1ad5bd2e2ece2ba9433231a90eec80e98b3ef91d", + "sha256": "270105bede250b3655a2b3e2ec1a5a093e3238f0049c999ae47d4109c9bcbe4a" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/source7747/TASK.json", + "retained": "retained/source7766/retained/source7747/TASK.json", + "git_blob": "819c9ff42e45011f64596f027a0be3eb81e7ace5", + "sha256": "f9bc51d9a73a22a2293e76bc9bf5b7b807575411ff0e2e56e8a6abeb6dc63c6a" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/source7747/VERIFY.json", + "retained": "retained/source7766/retained/source7747/VERIFY.json", + "git_blob": "659494422c6292d6d3991abdd2d98d950ed6bea8", + "sha256": "1444255057db7cd77fd9796c5a5be36daed4bae586f711c147b2c2c366fff043" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/source7747/verify.py", + "retained": "retained/source7766/retained/source7747/verify.py", + "git_blob": "4914eea2769af2b509fe1101b8dc3787a078fe56", + "sha256": "b32453df8dbb47af441ff736c51709c8e0c53fc2e13609f3841d48d977f8839b" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/retained/three-qubit-PROOF.md", + "retained": "retained/source7766/retained/three-qubit-PROOF.md", + "git_blob": "9f89ee36a0a1a0bdda09582d88477e15674fda5e", + "sha256": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "path": "research/clifford-four-qubit-threshold/verify.py", + "retained": "retained/source7766/verify.py", + "git_blob": "ccdf8a4e711bf73dc75637d9e1fcdb2ebbf0b4c9", + "sha256": "ffa4b3fd73c6c6e4a645a2c26e0eeb875fb46d7858c98485ffd47a48fb641ce9" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2", + "path": "research/clifford-width-twelve-nullity/CHARACTER-COLUMNS.json", + "retained": "retained/source7770/CHARACTER-COLUMNS.json", + "git_blob": "06766eb983480fc0962cffaab0cb0ddde24922da", + "sha256": "9b41c7569bb4c425a53eaec10ccba3eb33a7e8d595bbdf9be2041efb073eb384" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2", + "path": "research/clifford-width-twelve-nullity/CREDITS.md", + "retained": "retained/source7770/CREDITS.md", + "git_blob": "59a5eaf6996a6caed508281794b3fdc95a24699b", + "sha256": "2dc96df95fbac46797ce870d41845ccb4c36590fa8ad5690356b513352de23af" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2", + "path": "research/clifford-width-twelve-nullity/EXTERNAL.json", + "retained": "retained/source7770/EXTERNAL.json", + "git_blob": "9f66f6a8ca5f75aead3cfa2e35f9ee50d73fd7c8", + "sha256": "6b4c5714470965523c0a50041b4b6fceb816e03569d92fc84ab9ce4d8fe7c330" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2", + "path": "research/clifford-width-twelve-nullity/PROOF.md", + "retained": "retained/source7770/PROOF.md", + "git_blob": "0d80447ace10f734c6972e30016d2d4c139c796d", + "sha256": "70b04d38ea23b1b308f829a04552716c229506c1974613ec04abe17e20337824" + }, + { + "repository": "aliromman/integer-mult-bounds", + "commit": "ff9bdc0e82e75ab5ed39f3ff034ac8ddb3ea06d2", + "path": "research/clifford-width-twelve-nullity/README.md", + "retained": "retained/source7770/README.md", + "git_blob": "5d387f2801ff7316cce9d4c2f62fbcc4f29102a9", + "sha256": "a495ed8a4cb80b1923c1499a02ee7796f0be1d199e25e42f6920e538fad6bdd6" + } + ] +} diff --git a/research/clifford-width-ten-nullity/SOURCES.json b/research/clifford-width-ten-nullity/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/clifford-width-ten-nullity/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-width-ten-nullity/STABILIZERS.json b/research/clifford-width-ten-nullity/STABILIZERS.json new file mode 100644 index 0000000000..58b840aaba --- /dev/null +++ b/research/clifford-width-ten-nullity/STABILIZERS.json @@ -0,0 +1,6313 @@ +{ + "schema_version": 1, + "groups": [ + { + "kind": "minus", + "table": "O8-(2).2", + "order": 394813440, + "centralizers": [ + 394813440, + 368640, + 92160, + 6144, + 120960, + 2160, + 1296, + 3072, + 3072, + 384, + 128, + 360, + 1152, + 720, + 576, + 144, + 144, + 48, + 42, + 64, + 64, + 18, + 60, + 40, + 96, + 48, + 24, + 90, + 90, + 17, + 17, + 21, + 30, + 2903040, + 9216, + 7680, + 4608, + 768, + 768, + 256, + 4320, + 1296, + 288, + 216, + 144, + 72, + 192, + 64, + 16, + 60, + 288, + 96, + 72, + 24, + 24, + 14, + 18, + 20, + 24, + 30 + ], + "fusion_to_S8": [ + 1, + 3, + 4, + 7, + 8, + 10, + 11, + 15, + 14, + 19, + 22, + 24, + 27, + 29, + 28, + 35, + 37, + 41, + 42, + 46, + 45, + 49, + 52, + 53, + 58, + 62, + 63, + 70, + 69, + 73, + 72, + 77, + 81, + 2, + 6, + 12, + 13, + 18, + 16, + 20, + 26, + 31, + 32, + 33, + 40, + 39, + 44, + 43, + 47, + 51, + 57, + 56, + 61, + 66, + 64, + 68, + 74, + 75, + 79, + 80 + ], + "rows": [ + { + "degree": 1, + "sums_d1_to7": [ + 165593600, + 110396096, + 31541664, + 4205460, + 271320, + 8619, + 136 + ], + "restriction": [ + [ + 1, + 1 + ], + [ + 5, + 1 + ] + ] + }, + { + "degree": 1, + "sums_d1_to7": [ + -165593600, + 110396096, + -31541664, + 4205460, + -271320, + 8619, + -136 + ], + "restriction": [ + [ + 2, + 1 + ], + [ + 4, + 1 + ] + ] + }, + { + "degree": 34, + "sums_d1_to7": [ + -27591680, + 18367616, + 26275200, + 9119208, + 1313760, + 87414, + 2720 + ], + "restriction": [ + [ + 5, + 1 + ], + [ + 8, + 1 + ], + [ + 9, + 1 + ], + [ + 18, + 1 + ] + ] + }, + { + "degree": 34, + "sums_d1_to7": [ + 27591680, + 18367616, + -26275200, + 9119208, + -1313760, + 87414, + -2720 + ], + "restriction": [ + [ + 2, + 1 + ], + [ + 7, + 1 + ], + [ + 14, + 1 + ], + [ + 17, + 1 + ] + ] + }, + { + "degree": 51, + "sums_d1_to7": [ + -27600384, + 18366528, + 26286624, + 9120636, + 1310904, + 87057, + 2856 + ], + "restriction": [ + [ + 6, + 1 + ], + [ + 16, + 1 + ], + [ + 29, + 1 + ] + ] + }, + { + "degree": 51, + "sums_d1_to7": [ + 27600384, + 18366528, + -26286624, + 9120636, + -1310904, + 87057, + -2856 + ], + "restriction": [ + [ + 3, + 1 + ], + [ + 19, + 1 + ], + [ + 23, + 1 + ] + ] + }, + { + "degree": 84, + "sums_d1_to7": [ + -55200768, + 36830976, + 52573248, + 18215568, + 2621808, + 175644, + 5712 + ], + "restriction": [ + [ + 5, + 1 + ], + [ + 6, + 1 + ], + [ + 18, + 1 + ], + [ + 24, + 1 + ], + [ + 26, + 1 + ] + ] + }, + { + "degree": 84, + "sums_d1_to7": [ + 55200768, + 36830976, + -52573248, + 18215568, + -2621808, + 175644, + -5712 + ], + "restriction": [ + [ + 4, + 1 + ], + [ + 14, + 1 + ], + [ + 17, + 1 + ], + [ + 21, + 1 + ], + [ + 23, + 1 + ] + ] + }, + { + "degree": 204, + "sums_d1_to7": [ + 4804608, + -11802624, + -5963328, + 1593648, + 1148112, + 181764, + 10608 + ], + "restriction": [ + [ + 9, + 1 + ], + [ + 18, + 1 + ], + [ + 22, + 1 + ], + [ + 30, + 1 + ], + [ + 43, + 1 + ] + ] + }, + { + "degree": 204, + "sums_d1_to7": [ + -4804608, + -11802624, + 5963328, + 1593648, + -1148112, + 181764, + -10608 + ], + "restriction": [ + [ + 7, + 1 + ], + [ + 14, + 1 + ], + [ + 27, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ] + ] + }, + { + "degree": 204, + "sums_d1_to7": [ + 1044480, + -1383936, + -1302336, + 85680, + 257040, + 44676, + 816 + ], + "restriction": [ + [ + 13, + 1 + ], + [ + 34, + 1 + ], + [ + 50, + 1 + ] + ] + }, + { + "degree": 204, + "sums_d1_to7": [ + -1044480, + -1383936, + 1302336, + 85680, + -257040, + 44676, + -816 + ], + "restriction": [ + [ + 11, + 1 + ], + [ + 31, + 1 + ], + [ + 54, + 1 + ] + ] + }, + { + "degree": 357, + "sums_d1_to7": [ + 4569600, + -10167360, + -5654880, + 1195236, + 1071000, + 198135, + 14280 + ], + "restriction": [ + [ + 9, + 1 + ], + [ + 26, + 1 + ], + [ + 30, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ] + ] + }, + { + "degree": 357, + "sums_d1_to7": [ + -4569600, + -10167360, + 5654880, + 1195236, + -1071000, + 198135, + -14280 + ], + "restriction": [ + [ + 17, + 1 + ], + [ + 20, + 1 + ], + [ + 27, + 1 + ], + [ + 40, + 1 + ], + [ + 58, + 1 + ] + ] + }, + { + "degree": 476, + "sums_d1_to7": [ + 4630528, + -10174976, + -5734848, + 1205232, + 1090992, + 195636, + 13328 + ], + "restriction": [ + [ + 12, + 1 + ], + [ + 24, + 1 + ], + [ + 31, + 1 + ], + [ + 47, + 1 + ], + [ + 64, + 1 + ] + ] + }, + { + "degree": 476, + "sums_d1_to7": [ + -4630528, + -10174976, + 5734848, + 1205232, + -1090992, + 195636, + -13328 + ], + "restriction": [ + [ + 21, + 1 + ], + [ + 28, + 1 + ], + [ + 34, + 1 + ], + [ + 46, + 1 + ], + [ + 62, + 1 + ] + ] + }, + { + "degree": 476, + "sums_d1_to7": [ + 8529920, + -20593664, + -10578624, + 2713200, + 2027760, + 332724, + 20944 + ], + "restriction": [ + [ + 8, + 1 + ], + [ + 18, + 1 + ], + [ + 24, + 1 + ], + [ + 30, + 1 + ], + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 53, + 1 + ] + ] + }, + { + "degree": 476, + "sums_d1_to7": [ + -8529920, + -20593664, + 10578624, + 2713200, + -2027760, + 332724, + -20944 + ], + "restriction": [ + [ + 14, + 1 + ], + [ + 17, + 1 + ], + [ + 28, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 51, + 1 + ] + ] + }, + { + "degree": 595, + "sums_d1_to7": [ + -304640, + -38080, + 399840, + 49980, + -99960, + -12495, + 4760 + ], + "restriction": [ + [ + 10, + 1 + ], + [ + 42, + 1 + ], + [ + 45, + 1 + ], + [ + 49, + 1 + ], + [ + 61, + 1 + ] + ] + }, + { + "degree": 595, + "sums_d1_to7": [ + 304640, + -38080, + -399840, + 49980, + 99960, + -12495, + -4760 + ], + "restriction": [ + [ + 32, + 1 + ], + [ + 37, + 1 + ], + [ + 42, + 1 + ], + [ + 52, + 1 + ], + [ + 61, + 1 + ] + ] + }, + { + "degree": 714, + "sums_d1_to7": [ + 9139200, + -20334720, + -11309760, + 2390472, + 2142000, + 396270, + 28560 + ], + "restriction": [ + [ + 16, + 1 + ], + [ + 18, + 1 + ], + [ + 22, + 1 + ], + [ + 26, + 1 + ], + [ + 36, + 1 + ], + [ + 43, + 1 + ], + [ + 53, + 1 + ], + [ + 67, + 1 + ] + ] + }, + { + "degree": 714, + "sums_d1_to7": [ + -9139200, + -20334720, + 11309760, + 2390472, + -2142000, + 396270, + -28560 + ], + "restriction": [ + [ + 14, + 1 + ], + [ + 15, + 1 + ], + [ + 23, + 1 + ], + [ + 27, + 1 + ], + [ + 38, + 1 + ], + [ + 51, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ] + ] + }, + { + "degree": 714, + "sums_d1_to7": [ + 4752384, + -10190208, + -5894784, + 1225224, + 1130976, + 190638, + 11424 + ], + "restriction": [ + [ + 12, + 1 + ], + [ + 29, + 1 + ], + [ + 44, + 1 + ], + [ + 49, + 1 + ], + [ + 50, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 714, + "sums_d1_to7": [ + -4752384, + -10190208, + 5894784, + 1225224, + -1130976, + 190638, + -11424 + ], + "restriction": [ + [ + 11, + 1 + ], + [ + 19, + 1 + ], + [ + 37, + 1 + ], + [ + 44, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 1020, + "sums_d1_to7": [ + 9139200, + -21999360, + -11309760, + 2827440, + 2142000, + 370260, + 28560 + ], + "restriction": [ + [ + 16, + 1 + ], + [ + 24, + 1 + ], + [ + 29, + 1 + ], + [ + 36, + 1 + ], + [ + 49, + 1 + ], + [ + 56, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 1020, + "sums_d1_to7": [ + -9139200, + -21999360, + 11309760, + 2827440, + -2142000, + 370260, + -28560 + ], + "restriction": [ + [ + 19, + 1 + ], + [ + 23, + 1 + ], + [ + 32, + 1 + ], + [ + 35, + 1 + ], + [ + 51, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 1071, + "sums_d1_to7": [ + -1645056, + 11446848, + 2159136, + -2788884, + -539784, + 114597, + 25704 + ], + "restriction": [ + [ + 36, + 1 + ], + [ + 39, + 1 + ], + [ + 43, + 1 + ], + [ + 45, + 1 + ], + [ + 67, + 1 + ], + [ + 76, + 1 + ] + ] + }, + { + "degree": 1071, + "sums_d1_to7": [ + 1645056, + 11446848, + -2159136, + -2788884, + 539784, + 114597, + -25704 + ], + "restriction": [ + [ + 15, + 1 + ], + [ + 32, + 1 + ], + [ + 38, + 1 + ], + [ + 59, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ] + ] + }, + { + "degree": 1071, + "sums_d1_to7": [ + 8225280, + -20631744, + -10178784, + 2763180, + 1927800, + 320229, + 25704 + ], + "restriction": [ + [ + 13, + 1 + ], + [ + 26, + 1 + ], + [ + 29, + 1 + ], + [ + 55, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 1071, + "sums_d1_to7": [ + -8225280, + -20631744, + 10178784, + 2763180, + -1927800, + 320229, + -25704 + ], + "restriction": [ + [ + 19, + 1 + ], + [ + 21, + 1 + ], + [ + 54, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 2142, + "sums_d1_to7": [ + 0, + -11652480, + 0, + 3058776, + 0, + -182070, + 0 + ], + "restriction": [ + [ + 25, + 1 + ], + [ + 33, + 1 + ], + [ + 60, + 1 + ], + [ + 68, + 1 + ], + [ + 70, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 79, + 1 + ] + ] + }, + { + "degree": 1190, + "sums_d1_to7": [ + -609280, + -76160, + 799680, + 99960, + -199920, + -24990, + 9520 + ], + "restriction": [ + [ + 33, + 1 + ], + [ + 48, + 1 + ], + [ + 55, + 1 + ], + [ + 60, + 1 + ], + [ + 65, + 1 + ], + [ + 74, + 1 + ] + ] + }, + { + "degree": 1190, + "sums_d1_to7": [ + 609280, + -76160, + -799680, + 99960, + 199920, + -24990, + -9520 + ], + "restriction": [ + [ + 20, + 1 + ], + [ + 33, + 1 + ], + [ + 57, + 1 + ], + [ + 65, + 1 + ], + [ + 68, + 1 + ], + [ + 74, + 1 + ] + ] + }, + { + "degree": 1344, + "sums_d1_to7": [ + 14622720, + -33632256, + -18095616, + 4112640, + 3427200, + 616896, + 45696 + ], + "restriction": [ + [ + 18, + 1 + ], + [ + 24, + 1 + ], + [ + 26, + 1 + ], + [ + 29, + 1 + ], + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 56, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ] + ] + }, + { + "degree": 1344, + "sums_d1_to7": [ + -14622720, + -33632256, + 18095616, + 4112640, + -3427200, + 616896, + -45696 + ], + "restriction": [ + [ + 17, + 1 + ], + [ + 21, + 1 + ], + [ + 23, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 51, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ] + ] + }, + { + "degree": 1428, + "sums_d1_to7": [ + -1827840, + 11424000, + 2399040, + -2758896, + -599760, + 107100, + 28560 + ], + "restriction": [ + [ + 25, + 1 + ], + [ + 30, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 70, + 1 + ] + ] + }, + { + "degree": 1428, + "sums_d1_to7": [ + 1827840, + 11424000, + -2399040, + -2758896, + 599760, + 107100, + -28560 + ], + "restriction": [ + [ + 20, + 1 + ], + [ + 33, + 1 + ], + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 58, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 75, + 1 + ] + ] + }, + { + "degree": 4284, + "sums_d1_to7": [ + 0, + 11241216, + 0, + -2518992, + 0, + 47124, + 0 + ], + "restriction": [ + [ + 34, + 1 + ], + [ + 44, + 1 + ], + [ + 54, + 1 + ], + [ + 55, + 1 + ], + [ + 57, + 1 + ], + [ + 63, + 1 + ], + [ + 64, + 1 + ], + [ + 69, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 4284, + "sums_d1_to7": [ + 0, + -23304960, + 0, + 6117552, + 0, + -364140, + 0 + ], + "restriction": [ + [ + 39, + 1 + ], + [ + 41, + 1 + ], + [ + 61, + 1 + ], + [ + 70, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2176, + "sums_d1_to7": [ + -1392640, + 13021184, + 1827840, + -3107328, + -456960, + 110976, + 21760 + ], + "restriction": [ + [ + 31, + 1 + ], + [ + 44, + 1 + ], + [ + 47, + 1 + ], + [ + 54, + 1 + ], + [ + 56, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 79, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2176, + "sums_d1_to7": [ + 1392640, + 13021184, + -1827840, + -3107328, + 456960, + 110976, + -21760 + ], + "restriction": [ + [ + 34, + 1 + ], + [ + 46, + 1 + ], + [ + 50, + 1 + ], + [ + 55, + 1 + ], + [ + 57, + 1 + ], + [ + 62, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ] + ] + }, + { + "degree": 2295, + "sums_d1_to7": [ + -3525120, + 24528960, + 4626720, + -5976180, + -1156680, + 245565, + 55080 + ], + "restriction": [ + [ + 22, + 1 + ], + [ + 30, + 1 + ], + [ + 43, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 60, + 1 + ], + [ + 67, + 2 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ] + ] + }, + { + "degree": 2295, + "sums_d1_to7": [ + 3525120, + 24528960, + -4626720, + -5976180, + 1156680, + 245565, + -55080 + ], + "restriction": [ + [ + 27, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ], + [ + 51, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 2 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ] + ] + }, + { + "degree": 4590, + "sums_d1_to7": [ + 0, + -24969600, + 0, + 6554520, + 0, + -390150, + 0 + ], + "restriction": [ + [ + 42, + 1 + ], + [ + 45, + 1 + ], + [ + 52, + 1 + ], + [ + 61, + 1 + ], + [ + 71, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 2 + ] + ] + }, + { + "degree": 5670, + "sums_d1_to7": [ + 0, + -30844800, + 0, + 8096760, + 0, + -481950, + 0 + ], + "restriction": [ + [ + 60, + 1 + ], + [ + 65, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 72, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 5670, + "sums_d1_to7": [ + 0, + -30844800, + 0, + 8096760, + 0, + -481950, + 0 + ], + "restriction": [ + [ + 60, + 1 + ], + [ + 65, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2856, + "sums_d1_to7": [ + -3655680, + 22848000, + 4798080, + -5517792, + -1199520, + 214200, + 57120 + ], + "restriction": [ + [ + 36, + 1 + ], + [ + 41, + 1 + ], + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 49, + 1 + ], + [ + 53, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2856, + "sums_d1_to7": [ + 3655680, + 22848000, + -4798080, + -5517792, + 1199520, + 214200, + -57120 + ], + "restriction": [ + [ + 28, + 1 + ], + [ + 38, + 1 + ], + [ + 51, + 1 + ], + [ + 52, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 66, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 75, + 1 + ], + [ + 78, + 1 + ] + ] + }, + { + "degree": 2856, + "sums_d1_to7": [ + -731136, + 11332608, + 959616, + -2638944, + -239904, + 77112, + 11424 + ], + "restriction": [ + [ + 31, + 1 + ], + [ + 37, + 1 + ], + [ + 44, + 1 + ], + [ + 49, + 1 + ], + [ + 56, + 1 + ], + [ + 61, + 1 + ], + [ + 63, + 1 + ], + [ + 69, + 1 + ], + [ + 77, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2856, + "sums_d1_to7": [ + 731136, + 11332608, + -959616, + -2638944, + 239904, + 77112, + -11424 + ], + "restriction": [ + [ + 35, + 1 + ], + [ + 42, + 1 + ], + [ + 44, + 1 + ], + [ + 50, + 1 + ], + [ + 61, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 69, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 3264, + "sums_d1_to7": [ + -2924544, + 12951552, + 3838464, + -3015936, + -959616, + 88128, + 45696 + ], + "restriction": [ + [ + 36, + 1 + ], + [ + 45, + 1 + ], + [ + 47, + 1 + ], + [ + 49, + 1 + ], + [ + 56, + 1 + ], + [ + 61, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 3264, + "sums_d1_to7": [ + 2924544, + 12951552, + -3838464, + -3015936, + 959616, + 88128, + -45696 + ], + "restriction": [ + [ + 32, + 1 + ], + [ + 42, + 1 + ], + [ + 51, + 1 + ], + [ + 52, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 4096, + "sums_d1_to7": [ + -4456448, + 24510464, + 5849088, + -5849088, + -1462272, + 208896, + 69632 + ], + "restriction": [ + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 56, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 79, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 4096, + "sums_d1_to7": [ + 4456448, + 24510464, + -5849088, + -5849088, + 1462272, + 208896, + -69632 + ], + "restriction": [ + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 51, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ] + ] + }, + { + "degree": 4284, + "sums_d1_to7": [ + -3290112, + 11241216, + 4318272, + -2518992, + -1079568, + 47124, + 51408 + ], + "restriction": [ + [ + 39, + 1 + ], + [ + 53, + 1 + ], + [ + 55, + 1 + ], + [ + 56, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 70, + 1 + ], + [ + 74, + 1 + ], + [ + 76, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 4284, + "sums_d1_to7": [ + 3290112, + 11241216, + -4318272, + -2518992, + 1079568, + 47124, + -51408 + ], + "restriction": [ + [ + 35, + 1 + ], + [ + 46, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 63, + 1 + ], + [ + 68, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 4760, + "sums_d1_to7": [ + -2437120, + -304640, + 3198720, + 399840, + -799680, + -99960, + 38080 + ], + "restriction": [ + [ + 41, + 1 + ], + [ + 45, + 1 + ], + [ + 49, + 1 + ], + [ + 50, + 1 + ], + [ + 61, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 4760, + "sums_d1_to7": [ + 2437120, + -304640, + -3198720, + 399840, + 799680, + -99960, + -38080 + ], + "restriction": [ + [ + 37, + 1 + ], + [ + 52, + 1 + ], + [ + 54, + 1 + ], + [ + 59, + 1 + ], + [ + 61, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 66, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 5355, + "sums_d1_to7": [ + -2741760, + -342720, + 3598560, + 449820, + -899640, + -112455, + 42840 + ], + "restriction": [ + [ + 48, + 1 + ], + [ + 50, + 1 + ], + [ + 55, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 5355, + "sums_d1_to7": [ + 2741760, + -342720, + -3598560, + 449820, + 899640, + -112455, + -42840 + ], + "restriction": [ + [ + 54, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 65, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + } + ] + }, + { + "kind": "plus", + "table": "O8+(2).2", + "order": 348364800, + "centralizers": [ + 348364800, + 221184, + 92160, + 46080, + 6144, + 155520, + 77760, + 3888, + 1296, + 9216, + 1024, + 384, + 192, + 128, + 600, + 300, + 3456, + 1728, + 576, + 288, + 432, + 432, + 216, + 144, + 72, + 48, + 14, + 64, + 64, + 54, + 27, + 40, + 20, + 288, + 144, + 72, + 48, + 24, + 30, + 15, + 2903040, + 9216, + 7680, + 4608, + 768, + 768, + 256, + 4320, + 1296, + 288, + 216, + 144, + 72, + 192, + 64, + 16, + 60, + 288, + 96, + 72, + 24, + 24, + 14, + 18, + 20, + 24, + 30 + ], + "fusion_to_S8": [ + 1, + 3, + 4, + 5, + 7, + 8, + 9, + 11, + 10, + 14, + 15, + 19, + 21, + 23, + 24, + 25, + 27, + 30, + 28, + 36, + 35, + 29, + 34, + 37, + 38, + 41, + 42, + 45, + 46, + 49, + 50, + 53, + 54, + 55, + 59, + 63, + 62, + 67, + 69, + 71, + 2, + 6, + 13, + 12, + 18, + 17, + 20, + 26, + 31, + 32, + 33, + 40, + 39, + 43, + 44, + 48, + 51, + 56, + 57, + 60, + 65, + 66, + 68, + 74, + 76, + 78, + 80 + ], + "rows": [ + { + "degree": 1, + "sums_d1_to7": [ + 146112000, + 97407680, + 27830880, + 3710868, + 239400, + 7595, + 120 + ], + "restriction": [ + [ + 1, + 1 + ], + [ + 6, + 1 + ] + ] + }, + { + "degree": 1, + "sums_d1_to7": [ + -146112000, + 97407680, + -27830880, + 3710868, + -239400, + 7595, + -120 + ], + "restriction": [ + [ + 3, + 1 + ], + [ + 4, + 1 + ] + ] + }, + { + "degree": 28, + "sums_d1_to7": [ + 860160, + -2168320, + -1068480, + 302064, + 206640, + 31220, + 1680 + ], + "restriction": [ + [ + 9, + 1 + ], + [ + 22, + 1 + ] + ] + }, + { + "degree": 28, + "sums_d1_to7": [ + -860160, + -2168320, + 1068480, + 302064, + -206640, + 31220, + -1680 + ], + "restriction": [ + [ + 7, + 1 + ], + [ + 27, + 1 + ] + ] + }, + { + "degree": 35, + "sums_d1_to7": [ + -24353280, + 16260160, + 23194080, + 8033340, + 1156680, + 77665, + 2520 + ], + "restriction": [ + [ + 5, + 1 + ], + [ + 16, + 1 + ], + [ + 18, + 1 + ] + ] + }, + { + "degree": 35, + "sums_d1_to7": [ + 24353280, + 16260160, + -23194080, + 8033340, + -1156680, + 77665, + -2520 + ], + "restriction": [ + [ + 2, + 1 + ], + [ + 14, + 1 + ], + [ + 23, + 1 + ] + ] + }, + { + "degree": 70, + "sums_d1_to7": [ + 0, + -380800, + 0, + 99960, + 0, + -5950, + 0 + ], + "restriction": [ + [ + 25, + 1 + ], + [ + 33, + 1 + ] + ] + }, + { + "degree": 50, + "sums_d1_to7": [ + -24345600, + 16259200, + 23184000, + 8034600, + 1159200, + 77350, + 2400 + ], + "restriction": [ + [ + 6, + 1 + ], + [ + 12, + 1 + ], + [ + 13, + 1 + ], + [ + 29, + 1 + ] + ] + }, + { + "degree": 50, + "sums_d1_to7": [ + 24345600, + 16259200, + -23184000, + 8034600, + -1159200, + 77350, + -2400 + ], + "restriction": [ + [ + 3, + 1 + ], + [ + 11, + 1 + ], + [ + 19, + 1 + ], + [ + 21, + 1 + ] + ] + }, + { + "degree": 84, + "sums_d1_to7": [ + -48706560, + 32444160, + 46388160, + 16086672, + 2313360, + 154140, + 5040 + ], + "restriction": [ + [ + 5, + 1 + ], + [ + 6, + 1 + ], + [ + 24, + 1 + ], + [ + 26, + 1 + ], + [ + 29, + 1 + ] + ] + }, + { + "degree": 84, + "sums_d1_to7": [ + 48706560, + 32444160, + -46388160, + 16086672, + -2313360, + 154140, + -5040 + ], + "restriction": [ + [ + 4, + 1 + ], + [ + 17, + 1 + ], + [ + 19, + 1 + ], + [ + 21, + 1 + ], + [ + 23, + 1 + ] + ] + }, + { + "degree": 168, + "sums_d1_to7": [ + 0, + -3816960, + 0, + 481824, + 0, + 66360, + 0 + ], + "restriction": [ + [ + 11, + 1 + ], + [ + 12, + 1 + ], + [ + 34, + 1 + ], + [ + 44, + 1 + ] + ] + }, + { + "degree": 175, + "sums_d1_to7": [ + -268800, + 1870400, + 352800, + -455700, + -88200, + 18725, + 4200 + ], + "restriction": [ + [ + 10, + 1 + ], + [ + 36, + 1 + ], + [ + 45, + 1 + ] + ] + }, + { + "degree": 175, + "sums_d1_to7": [ + 268800, + 1870400, + -352800, + -455700, + 88200, + 18725, + -4200 + ], + "restriction": [ + [ + 15, + 1 + ], + [ + 32, + 1 + ], + [ + 52, + 1 + ] + ] + }, + { + "degree": 210, + "sums_d1_to7": [ + 4193280, + -10093440, + -5201280, + 1328040, + 997920, + 163590, + 10080 + ], + "restriction": [ + [ + 8, + 1 + ], + [ + 18, + 1 + ], + [ + 22, + 1 + ], + [ + 36, + 1 + ], + [ + 43, + 1 + ] + ] + }, + { + "degree": 210, + "sums_d1_to7": [ + -4193280, + -10093440, + 5201280, + 1328040, + -997920, + 163590, + -10080 + ], + "restriction": [ + [ + 7, + 1 + ], + [ + 14, + 1 + ], + [ + 15, + 1 + ], + [ + 38, + 1 + ], + [ + 51, + 1 + ] + ] + }, + { + "degree": 420, + "sums_d1_to7": [ + 0, + -2284800, + 0, + 599760, + 0, + -35700, + 0 + ], + "restriction": [ + [ + 10, + 1 + ], + [ + 41, + 1 + ], + [ + 52, + 1 + ], + [ + 61, + 1 + ] + ] + }, + { + "degree": 300, + "sums_d1_to7": [ + 4147200, + -10099200, + -5140800, + 1335600, + 982800, + 161700, + 10800 + ], + "restriction": [ + [ + 8, + 1 + ], + [ + 24, + 1 + ], + [ + 53, + 1 + ], + [ + 56, + 1 + ] + ] + }, + { + "degree": 300, + "sums_d1_to7": [ + -4147200, + -10099200, + 5140800, + 1335600, + -982800, + 161700, + -10800 + ], + "restriction": [ + [ + 17, + 1 + ], + [ + 35, + 1 + ], + [ + 46, + 1 + ], + [ + 51, + 1 + ] + ] + }, + { + "degree": 350, + "sums_d1_to7": [ + -537600, + 3740800, + 705600, + -911400, + -176400, + 37450, + 8400 + ], + "restriction": [ + [ + 30, + 1 + ], + [ + 48, + 1 + ], + [ + 60, + 1 + ] + ] + }, + { + "degree": 350, + "sums_d1_to7": [ + 537600, + 3740800, + -705600, + -911400, + 176400, + 37450, + -8400 + ], + "restriction": [ + [ + 20, + 1 + ], + [ + 40, + 1 + ], + [ + 68, + 1 + ] + ] + }, + { + "degree": 525, + "sums_d1_to7": [ + 4032000, + -10113600, + -4989600, + 1354500, + 945000, + 156975, + 12600 + ], + "restriction": [ + [ + 13, + 1 + ], + [ + 26, + 1 + ], + [ + 48, + 1 + ], + [ + 55, + 1 + ], + [ + 64, + 1 + ] + ] + }, + { + "degree": 525, + "sums_d1_to7": [ + -4032000, + -10113600, + 4989600, + 1354500, + -945000, + 156975, + -12600 + ], + "restriction": [ + [ + 20, + 1 + ], + [ + 21, + 1 + ], + [ + 54, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ] + ] + }, + { + "degree": 567, + "sums_d1_to7": [ + 7257600, + -16148160, + -8981280, + 1898316, + 1701000, + 314685, + 22680 + ], + "restriction": [ + [ + 9, + 1 + ], + [ + 18, + 1 + ], + [ + 26, + 1 + ], + [ + 30, + 1 + ], + [ + 43, + 1 + ], + [ + 53, + 1 + ], + [ + 67, + 1 + ] + ] + }, + { + "degree": 567, + "sums_d1_to7": [ + -7257600, + -16148160, + 8981280, + 1898316, + -1701000, + 314685, + -22680 + ], + "restriction": [ + [ + 14, + 1 + ], + [ + 17, + 1 + ], + [ + 27, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ] + ] + }, + { + "degree": 1134, + "sums_d1_to7": [ + 0, + -6168960, + 0, + 1619352, + 0, + -96390, + 0 + ], + "restriction": [ + [ + 65, + 1 + ], + [ + 66, + 1 + ], + [ + 71, + 1 + ], + [ + 77, + 1 + ] + ] + }, + { + "degree": 700, + "sums_d1_to7": [ + 4300800, + -8243200, + -5342400, + 898800, + 1033200, + 175700, + 8400 + ], + "restriction": [ + [ + 13, + 1 + ], + [ + 29, + 1 + ], + [ + 34, + 1 + ], + [ + 44, + 1 + ], + [ + 50, + 1 + ], + [ + 55, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 700, + "sums_d1_to7": [ + -4300800, + -8243200, + 5342400, + 898800, + -1033200, + 175700, + -8400 + ], + "restriction": [ + [ + 11, + 1 + ], + [ + 19, + 1 + ], + [ + 31, + 1 + ], + [ + 44, + 1 + ], + [ + 54, + 1 + ], + [ + 57, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 700, + "sums_d1_to7": [ + 8064000, + -18323200, + -9979200, + 2209200, + 1890000, + 343700, + 25200 + ], + "restriction": [ + [ + 16, + 1 + ], + [ + 18, + 1 + ], + [ + 24, + 1 + ], + [ + 36, + 1 + ], + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 49, + 1 + ], + [ + 67, + 1 + ] + ] + }, + { + "degree": 700, + "sums_d1_to7": [ + -8064000, + -18323200, + 9979200, + 2209200, + -1890000, + 343700, + -25200 + ], + "restriction": [ + [ + 14, + 1 + ], + [ + 23, + 1 + ], + [ + 28, + 1 + ], + [ + 32, + 1 + ], + [ + 38, + 1 + ], + [ + 51, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ] + ] + }, + { + "degree": 1400, + "sums_d1_to7": [ + 0, + -7616000, + 0, + 1999200, + 0, + -119000, + 0 + ], + "restriction": [ + [ + 25, + 1 + ], + [ + 41, + 1 + ], + [ + 66, + 1 + ], + [ + 70, + 1 + ], + [ + 75, + 1 + ], + [ + 79, + 1 + ] + ] + }, + { + "degree": 840, + "sums_d1_to7": [ + -645120, + 5591040, + 846720, + -1340640, + -211680, + 49560, + 10080 + ], + "restriction": [ + [ + 31, + 1 + ], + [ + 37, + 1 + ], + [ + 47, + 1 + ], + [ + 49, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 840, + "sums_d1_to7": [ + 645120, + 5591040, + -846720, + -1340640, + 211680, + 49560, + -10080 + ], + "restriction": [ + [ + 28, + 1 + ], + [ + 42, + 1 + ], + [ + 50, + 1 + ], + [ + 62, + 1 + ], + [ + 78, + 1 + ] + ] + }, + { + "degree": 1680, + "sums_d1_to7": [ + 0, + -9139200, + 0, + 2399040, + 0, + -142800, + 0 + ], + "restriction": [ + [ + 33, + 1 + ], + [ + 60, + 1 + ], + [ + 65, + 1 + ], + [ + 68, + 1 + ], + [ + 70, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ] + ] + }, + { + "degree": 972, + "sums_d1_to7": [ + 7464960, + -16174080, + -9253440, + 1932336, + 1769040, + 306180, + 19440 + ], + "restriction": [ + [ + 12, + 1 + ], + [ + 24, + 1 + ], + [ + 29, + 1 + ], + [ + 31, + 1 + ], + [ + 44, + 1 + ], + [ + 55, + 1 + ], + [ + 56, + 1 + ], + [ + 64, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 972, + "sums_d1_to7": [ + -7464960, + -16174080, + 9253440, + 1932336, + -1769040, + 306180, + -19440 + ], + "restriction": [ + [ + 19, + 1 + ], + [ + 21, + 1 + ], + [ + 34, + 1 + ], + [ + 35, + 1 + ], + [ + 44, + 1 + ], + [ + 46, + 1 + ], + [ + 57, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 1050, + "sums_d1_to7": [ + 8064000, + -20227200, + -9979200, + 2709000, + 1890000, + 313950, + 25200 + ], + "restriction": [ + [ + 16, + 1 + ], + [ + 26, + 1 + ], + [ + 29, + 1 + ], + [ + 49, + 1 + ], + [ + 50, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 1050, + "sums_d1_to7": [ + -8064000, + -20227200, + 9979200, + 2709000, + -1890000, + 313950, + -25200 + ], + "restriction": [ + [ + 19, + 1 + ], + [ + 23, + 1 + ], + [ + 37, + 1 + ], + [ + 54, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 2100, + "sums_d1_to7": [ + 0, + 5510400, + 0, + -1234800, + 0, + 23100, + 0 + ], + "restriction": [ + [ + 33, + 1 + ], + [ + 34, + 1 + ], + [ + 54, + 1 + ], + [ + 55, + 1 + ], + [ + 57, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 79, + 1 + ] + ] + }, + { + "degree": 1344, + "sums_d1_to7": [ + 12902400, + -30535680, + -15966720, + 3854592, + 3024000, + 530880, + 40320 + ], + "restriction": [ + [ + 18, + 1 + ], + [ + 24, + 1 + ], + [ + 26, + 1 + ], + [ + 29, + 1 + ], + [ + 47, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 56, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ] + ] + }, + { + "degree": 1344, + "sums_d1_to7": [ + -12902400, + -30535680, + 15966720, + 3854592, + -3024000, + 530880, + -40320 + ], + "restriction": [ + [ + 17, + 1 + ], + [ + 21, + 1 + ], + [ + 23, + 1 + ], + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 51, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ] + ] + }, + { + "degree": 2688, + "sums_d1_to7": [ + 0, + 12472320, + 0, + -2935296, + 0, + 94080, + 0 + ], + "restriction": [ + [ + 35, + 1 + ], + [ + 44, + 1 + ], + [ + 55, + 1 + ], + [ + 56, + 1 + ], + [ + 57, + 1 + ], + [ + 63, + 1 + ], + [ + 69, + 1 + ], + [ + 74, + 1 + ], + [ + 77, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 1400, + "sums_d1_to7": [ + -2150400, + 14963200, + 2822400, + -3645600, + -705600, + 149800, + 33600 + ], + "restriction": [ + [ + 22, + 1 + ], + [ + 36, + 1 + ], + [ + 41, + 1 + ], + [ + 43, + 1 + ], + [ + 45, + 1 + ], + [ + 53, + 1 + ], + [ + 67, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ] + ] + }, + { + "degree": 1400, + "sums_d1_to7": [ + 2150400, + 14963200, + -2822400, + -3645600, + 705600, + 149800, + -33600 + ], + "restriction": [ + [ + 15, + 1 + ], + [ + 27, + 1 + ], + [ + 38, + 1 + ], + [ + 51, + 1 + ], + [ + 52, + 1 + ], + [ + 59, + 1 + ], + [ + 66, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ] + ] + }, + { + "degree": 1575, + "sums_d1_to7": [ + -2419200, + 16833600, + 3175200, + -4101300, + -793800, + 168525, + 37800 + ], + "restriction": [ + [ + 22, + 1 + ], + [ + 30, + 1 + ], + [ + 43, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 67, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ] + ] + }, + { + "degree": 1575, + "sums_d1_to7": [ + 2419200, + 16833600, + -3175200, + -4101300, + 793800, + 168525, + -37800 + ], + "restriction": [ + [ + 27, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ], + [ + 51, + 1 + ], + [ + 58, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ] + ] + }, + { + "degree": 3150, + "sums_d1_to7": [ + 0, + -17136000, + 0, + 4498200, + 0, + -267750, + 0 + ], + "restriction": [ + [ + 42, + 1 + ], + [ + 45, + 1 + ], + [ + 52, + 1 + ], + [ + 61, + 1 + ], + [ + 71, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2100, + "sums_d1_to7": [ + -1612800, + 5510400, + 2116800, + -1234800, + -529200, + 23100, + 25200 + ], + "restriction": [ + [ + 25, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 55, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 70, + 1 + ], + [ + 74, + 1 + ], + [ + 79, + 1 + ] + ] + }, + { + "degree": 2100, + "sums_d1_to7": [ + 1612800, + 5510400, + -2116800, + -1234800, + 529200, + 23100, + -25200 + ], + "restriction": [ + [ + 20, + 1 + ], + [ + 33, + 1 + ], + [ + 46, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 79, + 1 + ] + ] + }, + { + "degree": 4200, + "sums_d1_to7": [ + 0, + 11020800, + 0, + -2469600, + 0, + 46200, + 0 + ], + "restriction": [ + [ + 37, + 1 + ], + [ + 44, + 1 + ], + [ + 49, + 1 + ], + [ + 50, + 1 + ], + [ + 54, + 1 + ], + [ + 61, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 64, + 1 + ], + [ + 69, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2240, + "sums_d1_to7": [ + -2580480, + 14909440, + 3386880, + -3575040, + -846720, + 132160, + 40320 + ], + "restriction": [ + [ + 36, + 1 + ], + [ + 43, + 1 + ], + [ + 45, + 1 + ], + [ + 47, + 1 + ], + [ + 49, + 1 + ], + [ + 56, + 1 + ], + [ + 61, + 1 + ], + [ + 67, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2240, + "sums_d1_to7": [ + 2580480, + 14909440, + -3386880, + -3575040, + 846720, + 132160, + -40320 + ], + "restriction": [ + [ + 32, + 1 + ], + [ + 38, + 1 + ], + [ + 42, + 1 + ], + [ + 51, + 1 + ], + [ + 52, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ] + ] + }, + { + "degree": 4480, + "sums_d1_to7": [ + 0, + -24371200, + 0, + 6397440, + 0, + -380800, + 0 + ], + "restriction": [ + [ + 41, + 1 + ], + [ + 45, + 1 + ], + [ + 52, + 1 + ], + [ + 61, + 1 + ], + [ + 66, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2268, + "sums_d1_to7": [ + -2903040, + 18144000, + 3810240, + -4381776, + -952560, + 170100, + 45360 + ], + "restriction": [ + [ + 30, + 1 + ], + [ + 39, + 1 + ], + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 53, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 70, + 1 + ], + [ + 76, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2268, + "sums_d1_to7": [ + 2903040, + 18144000, + -3810240, + -4381776, + 952560, + 170100, + -45360 + ], + "restriction": [ + [ + 28, + 1 + ], + [ + 38, + 1 + ], + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 68, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 75, + 1 + ], + [ + 78, + 1 + ] + ] + }, + { + "degree": 4536, + "sums_d1_to7": [ + 0, + -24675840, + 0, + 6477408, + 0, + -385560, + 0 + ], + "restriction": [ + [ + 39, + 1 + ], + [ + 60, + 1 + ], + [ + 68, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2835, + "sums_d1_to7": [ + -1451520, + -181440, + 1905120, + 238140, + -476280, + -59535, + 22680 + ], + "restriction": [ + [ + 39, + 1 + ], + [ + 42, + 1 + ], + [ + 45, + 1 + ], + [ + 49, + 1 + ], + [ + 61, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 76, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 2835, + "sums_d1_to7": [ + 1451520, + -181440, + -1905120, + 238140, + 476280, + -59535, + -22680 + ], + "restriction": [ + [ + 32, + 1 + ], + [ + 37, + 1 + ], + [ + 42, + 1 + ], + [ + 59, + 1 + ], + [ + 61, + 1 + ], + [ + 63, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 5670, + "sums_d1_to7": [ + 0, + -30844800, + 0, + 8096760, + 0, + -481950, + 0 + ], + "restriction": [ + [ + 60, + 1 + ], + [ + 65, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 2 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 3200, + "sums_d1_to7": [ + -1228800, + 14848000, + 1612800, + -3494400, + -403200, + 112000, + 19200 + ], + "restriction": [ + [ + 31, + 1 + ], + [ + 44, + 1 + ], + [ + 47, + 1 + ], + [ + 54, + 1 + ], + [ + 56, + 1 + ], + [ + 63, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 69, + 1 + ], + [ + 74, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 3200, + "sums_d1_to7": [ + 1228800, + 14848000, + -1612800, + -3494400, + 403200, + 112000, + -19200 + ], + "restriction": [ + [ + 34, + 1 + ], + [ + 46, + 1 + ], + [ + 50, + 1 + ], + [ + 55, + 1 + ], + [ + 57, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 69, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 4096, + "sums_d1_to7": [ + -3932160, + 19005440, + 5160960, + -4472832, + -1290240, + 143360, + 61440 + ], + "restriction": [ + [ + 43, + 1 + ], + [ + 47, + 1 + ], + [ + 48, + 1 + ], + [ + 53, + 1 + ], + [ + 56, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 4096, + "sums_d1_to7": [ + 3932160, + 19005440, + -5160960, + -4472832, + 1290240, + 143360, + -61440 + ], + "restriction": [ + [ + 40, + 1 + ], + [ + 46, + 1 + ], + [ + 51, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 4200, + "sums_d1_to7": [ + -3225600, + 11020800, + 4233600, + -2469600, + -1058400, + 46200, + 50400 + ], + "restriction": [ + [ + 36, + 1 + ], + [ + 41, + 1 + ], + [ + 49, + 1 + ], + [ + 53, + 1 + ], + [ + 56, + 1 + ], + [ + 61, + 1 + ], + [ + 64, + 1 + ], + [ + 67, + 1 + ], + [ + 69, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 1 + ] + ] + }, + { + "degree": 4200, + "sums_d1_to7": [ + 3225600, + 11020800, + -4233600, + -2469600, + 1058400, + 46200, + -50400 + ], + "restriction": [ + [ + 35, + 1 + ], + [ + 51, + 1 + ], + [ + 52, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 61, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 66, + 1 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ] + ] + }, + { + "degree": 6075, + "sums_d1_to7": [ + -3110400, + -388800, + 4082400, + 510300, + -1020600, + -127575, + 48600 + ], + "restriction": [ + [ + 48, + 1 + ], + [ + 50, + 1 + ], + [ + 55, + 1 + ], + [ + 60, + 1 + ], + [ + 64, + 1 + ], + [ + 65, + 1 + ], + [ + 67, + 2 + ], + [ + 69, + 1 + ], + [ + 70, + 1 + ], + [ + 71, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 76, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 2 + ] + ] + }, + { + "degree": 6075, + "sums_d1_to7": [ + 3110400, + -388800, + -4082400, + 510300, + 1020600, + -127575, + -48600 + ], + "restriction": [ + [ + 54, + 1 + ], + [ + 57, + 1 + ], + [ + 58, + 1 + ], + [ + 59, + 1 + ], + [ + 62, + 1 + ], + [ + 63, + 1 + ], + [ + 65, + 1 + ], + [ + 66, + 1 + ], + [ + 68, + 2 + ], + [ + 72, + 1 + ], + [ + 73, + 1 + ], + [ + 74, + 1 + ], + [ + 75, + 1 + ], + [ + 77, + 1 + ], + [ + 78, + 1 + ], + [ + 79, + 1 + ], + [ + 80, + 1 + ], + [ + 81, + 2 + ] + ] + } + ] + } + ], + "archive_checks": { + "ordinary_inner_products": 14650, + "restriction_coefficients": 10287, + "omitted_galois_action_rejected": true, + "quadratic_period": "t^2=17; conjugation fixes t; Galois(3) negates t" + } +} diff --git a/research/clifford-width-ten-nullity/TASK.json b/research/clifford-width-ten-nullity/TASK.json new file mode 100644 index 0000000000..cdcf690d8e --- /dev/null +++ b/research/clifford-width-ten-nullity/TASK.json @@ -0,0 +1,95 @@ +{ + "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": "Exact full four-qubit width-ten projective Gram nullity 193919902208, with all 127 quadratic-stabilizer multiplicities and fifteen absent modules.", + "scope_change_reason": "Resolve the open width-ten even sector using authenticated full orthogonal-stabilizer tables and their class fusions, after ordinary derangement constraints leave nontrivial kernels.", + "bottleneck_link": "Complete the native-alphabet dependence certificate; no physical supplier or caller-cost gain is inferred.", + "budget_minutes": 60, + "stop_rule": "Stop after both actual quadratic sectors have complete exact multiplicities and the full width-ten nullity passes independent checks; leave conditioning, larger qubit counts and physical costs explicit.", + "outcome": "completed", + "evidence": "PROOF.md gives the actual Bell-line little-group decomposition. STABILIZERS.json and RESULT.json give all multiplicities, sparse restrictions and source-authenticated projections.", + "author": "Ali Romman", + "ai_assistance": "Substantial OpenAI Codex assistance in research, implementation, verification and writing", + "open_questions": [ + { + "question": "Determine exact spectral endpoints at the first independent width.", + "why_it_matters": "Full support and nullity alone do not bound numerical conditioning.", + "first_step": "Compute and compare every admitted irreducible block eigenvalue at width thirteen.", + "blocked_by": "The present result fixes width ten and central character minus one." + } + ] +} diff --git a/research/clifford-width-ten-nullity/VERIFY.json b/research/clifford-width-ten-nullity/VERIFY.json new file mode 100644 index 0000000000..0a5526fe4b --- /dev/null +++ b/research/clifford-width-ten-nullity/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 both quadratic-stabilizer projections, actual fusion point characters, all 127 multiplicities by two formulas, all missing modules and complete regular-sector dimensions." + }, + { + "argv": [ + "{python}", + "-W", + "error", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Check both quadratic-stabilizer projections, actual fusion point characters, all 127 multiplicities by two formulas, all missing modules and complete regular-sector dimensions." + } + ] +} diff --git a/research/clifford-width-ten-nullity/extract.py b/research/clifford-width-ten-nullity/extract.py new file mode 100644 index 0000000000..9e3e2469cc --- /dev/null +++ b/research/clifford-width-ten-nullity/extract.py @@ -0,0 +1,205 @@ +"""Extract exact stabilizer data from the authenticated CTblLib release. + +The MOT and ALF record selection extends Nick Petalas's retained parser. +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +from hashlib import sha256 +from io import BytesIO +import json +from pathlib import Path +import re +import tarfile + +ROOT = Path(__file__).resolve().parent +RESIDUES = {x*x % 17 for x in range(1, 17)} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def reduce17(coefficients): + return [x-coefficients[16] for x in coefficients[:16]] + + +def period_basis(): + t = [int(i == 0) + 2 * (i in RESIDUES) for i in range(17)] + square = [sum(t[j]*t[(i-j) % 17] for j in range(17)) for i in range(17)] + require(reduce17(square) == [17]+[0]*15, 'quadratic period square') + conjugate = [t[-i % 17] for i in range(17)] + require(conjugate == t, 'real quadratic period') + changed = [0]*17 + for i, x in enumerate(t): + changed[3*i % 17] = x + require(reduce17(changed) == [-x for x in reduce17(t)], 'Galois period action') + return reduce17(t) + + +PERIOD = period_basis() + + +def scalar(text): + if re.fullmatch(r'-?[0-9]+', text): + return 2*int(text), 0 + terms = re.findall(r'([+-]?)(E\(17\)(?:\^[0-9]+)?)', text) + require(''.join(sign+term for sign, term in terms) == text, 'unsupported table scalar') + coefficients = [0]*17 + for sign, term in terms: + exponent = int(term.split('^')[1]) if '^' in term else 1 + coefficients[exponent % 17] += -1 if sign == '-' else 1 + vector = reduce17(coefficients) + k = next(i for i in range(1, 16) if PERIOD[i]) + b, remainder = divmod(2*vector[k], PERIOD[k]) + require(remainder == 0, 'quadratic period coefficient') + a = 2*vector[0]-b*PERIOD[0] + require([a*(i == 0)+b*PERIOD[i] for i in range(16)] == [2*x for x in vector], + 'quadratic period span') + return a, b + + +def multiply(x, y): + a, b = x + c, d = y + first, second = a*c+17*b*d, a*d+b*c + require(first % 2 == second % 2 == 0, 'half-integral character product') + return first//2, second//2 + + +def bracket(text, start): + depth = 0 + for i in range(start, len(text)): + depth += (text[i] == '[')-(text[i] == ']') + if depth == 0: + return text[start+1:i] + raise ValueError('unbalanced table list') + + +def split(text): + result, depth, start = [], 0, 0 + for i, char in enumerate(text): + depth += (char == '[')-(char == ']') + if char == ',' and depth == 0: + result.append(text[start:i]) + start = i+1 + return result+[text[start:]] + + +def parse_table(text, name): + marker = 'MOT("'+name+'",\n' + require(text.count(marker) == 1, 'table record identity') + block = text.split(marker, 1)[1].split('\nARC("'+name+'"', 1)[0] + numbers = block.split('],\n', 1)[1] + centralizers = json.loads(numbers.split('],\n', 1)[0]+']') + start = block.index('\n[[1,1,1,')+1 + raw_rows = split(re.sub(r'\s+', '', bracket(block, start))) + rows = [] + for raw in raw_rows: + cells = split(raw[1:-1]) + if cells[0] == 'TENSOR': + i, j = json.loads(cells[1]) + rows.append([multiply(a, b) for a, b in zip(rows[i-1], rows[j-1], strict=True)]) + elif cells[0] == 'GALOIS': + i, power = json.loads(cells[1]) + require(power % 17 != 0, 'Galois power') + sign = 1 if power % 17 in RESIDUES else -1 + rows.append([(a, sign*b) for a, b in rows[i-1]]) + else: + rows.append([scalar(cell) for cell in cells]) + n = len(centralizers) + require(len(rows) == n and all(len(row) == n for row in rows), 'character table shape') + require(rows[0] == [(2, 0)]*n, 'trivial character row') + order = centralizers[0] + require(all(c > 0 and order % c == 0 for c in centralizers), 'table class centralizer') + sizes = [order//c for c in centralizers] + require(sum(sizes) == order, 'full class-size sum') + require(sum((row[0][0]//2)**2 for row in rows) == order, 'degree-square sum') + ordinary_orthogonality(rows, sizes, order) + return rows, centralizers + + +def inner(left, right, sizes, order): + real = radical = 0 + for (a, b), (c, d), size in zip(left, right, sizes, strict=True): + real += size*(a*c+17*b*d) + radical += size*(a*d+b*c) + value, remainder = divmod(real, 4*order) + require(radical == remainder == 0, 'nonintegral character inner product') + return value + + +def ordinary_orthogonality(rows, sizes, order): + for i, left in enumerate(rows): + for j, right in enumerate(rows): + require(inner(left, right, sizes, order) == (i == j), 'ordinary character orthogonality') + + +def extract(archive): + metadata = json.loads((ROOT/'EXTERNAL.json').read_text()) + with archive.open('rb') as stream: + raw = stream.read(20*1024*1024+1) + require(sha256(raw).hexdigest() == metadata['archive_sha256'], 'release archive hash') + texts = {} + with tarfile.open(fileobj=BytesIO(raw), mode='r:gz') as tar: + for member, digest in metadata['members'].items(): + info = tar.getmember(member) + require(info.isfile() and 0 < info.size < 1024*1024, 'table member size') + stream = tar.extractfile(info) + require(stream is not None, 'table member missing') + with stream: + data = stream.read(info.size+1) + require(sha256(data).hexdigest() == digest, 'table member hash') + texts[Path(member).name] = data.decode('ascii') + srows, scenters = parse_table(texts['ctosymp1.tbl'], 'S8(2)') + require(len(srows) == 81 and scenters[0] == 47_377_612_800, 'symplectic table') + dims = [] + for j in range(81): + fixed = 2+(srows[4][j][0]+srows[5][j][0])//2 + require(srows[4][j][1] == srows[5][j][1] == 0 and fixed.bit_count() == 1, + 'symplectic fixed-vector character') + dims.append(fixed.bit_length()-1) + groups = [] + for kind, name, member, expected_classes in [ + ('minus', 'O8-(2).2', 'ctoorth3.tbl', 60), + ('plus', 'O8+(2).2', 'ctoorth2.tbl', 67)]: + rows, centralizers = parse_table(texts[member], name) + fusion = json.loads(texts[member].split('ALF("'+name+'","S8(2)",', 1)[1].split('],', 1)[0]+']') + require(len(rows) == len(fusion) == expected_classes, 'stabilizer table size') + order = centralizers[0] + sizes = [order//c for c in centralizers] + if kind == 'minus': + bad = [list(row) for row in rows] + require(bad[44] != bad[45], 'distinct Galois rows') + bad[45] = bad[44] + try: + ordinary_orthogonality(bad, sizes, order) + except ValueError as error: + require(str(error) == 'ordinary character orthogonality', 'Galois control reason') + else: + raise ValueError('omitted Galois action accepted') + hdims = [dims[j-1] for j in fusion] + require(rows[1] == [(2*(-1)**d, 0) for d in hdims], 'actual Dickson row') + records = [] + for row in rows: + degree = row[0][0]//2 + require(row[0][1] == 0 and row[0][0] % 2 == 0, 'integer degree') + sums = [] + for d in range(1, 8): + real = sum(size*value[0] for size, value, dim in zip(sizes, row, hdims, strict=True) if dim == d) + radical = sum(size*value[1] for size, value, dim in zip(sizes, row, hdims, strict=True) if dim == d) + require(radical == 0 and real % 2 == 0, 'rational fixed-dimension sum') + sums.append(real//2) + restriction = [] + for j, srow in enumerate(srows, 1): + coefficient = inner(row, [srow[k-1] for k in fusion], sizes, order) + require(coefficient >= 0, 'negative restriction coefficient') + if coefficient: + restriction.append([j, coefficient]) + records.append({'degree': degree, 'sums_d1_to7': sums, 'restriction': restriction}) + groups.append({'kind': kind, 'table': name, 'order': order, + 'centralizers': centralizers, 'fusion_to_S8': fusion, 'rows': records}) + return {'schema_version': 1, 'groups': groups, + 'archive_checks': {'ordinary_inner_products': 81**2+60**2+67**2, + 'restriction_coefficients': 81*(60+67), + 'omitted_galois_action_rejected': True, + 'quadratic_period': 't^2=17; conjugation fixes t; Galois(3) negates t'}} diff --git a/research/clifford-width-ten-nullity/retained/source7766/.gitattributes b/research/clifford-width-ten-nullity/retained/source7766/.gitattributes new file mode 100644 index 0000000000..130a3ecaa2 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/.gitattributes @@ -0,0 +1 @@ +retained/** -text whitespace=cr-at-eol diff --git a/research/clifford-width-ten-nullity/retained/source7766/CREDITS.md b/research/clifford-width-ten-nullity/retained/source7766/CREDITS.md new file mode 100644 index 0000000000..db09795409 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/EXTERNAL.json b/research/clifford-width-ten-nullity/retained/source7766/EXTERNAL.json new file mode 100644 index 0000000000..26f473de73 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/PROOF.md b/research/clifford-width-ten-nullity/retained/source7766/PROOF.md new file mode 100644 index 0000000000..d4fa0b807b --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/README.md b/research/clifford-width-ten-nullity/retained/source7766/README.md new file mode 100644 index 0000000000..72e1681213 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/RESULT.json b/research/clifford-width-ten-nullity/retained/source7766/RESULT.json new file mode 100644 index 0000000000..bbd3a1de1d --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/SOURCE-PINS.json b/research/clifford-width-ten-nullity/retained/source7766/SOURCE-PINS.json new file mode 100644 index 0000000000..6a30697dde --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/SOURCES.json b/research/clifford-width-ten-nullity/retained/source7766/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/TASK.json b/research/clifford-width-ten-nullity/retained/source7766/TASK.json new file mode 100644 index 0000000000..8899527d79 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/VERIFY.json b/research/clifford-width-ten-nullity/retained/source7766/VERIFY.json new file mode 100644 index 0000000000..5ddaf52c4c --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/source7747/PROJECTION.json b/research/clifford-width-ten-nullity/retained/source7766/retained/source7747/PROJECTION.json new file mode 100644 index 0000000000..406f84b469 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/source7747/README.md b/research/clifford-width-ten-nullity/retained/source7766/retained/source7747/README.md new file mode 100644 index 0000000000..d31d4d24c9 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/source7747/SOURCES.json b/research/clifford-width-ten-nullity/retained/source7766/retained/source7747/SOURCES.json new file mode 100644 index 0000000000..1ad5bd2e2e --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/source7747/TASK.json b/research/clifford-width-ten-nullity/retained/source7766/retained/source7747/TASK.json new file mode 100644 index 0000000000..819c9ff42e --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/source7747/VERIFY.json b/research/clifford-width-ten-nullity/retained/source7766/retained/source7747/VERIFY.json new file mode 100644 index 0000000000..659494422c --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/source7747/verify.py b/research/clifford-width-ten-nullity/retained/source7766/retained/source7747/verify.py new file mode 100644 index 0000000000..4914eea276 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/retained/three-qubit-PROOF.md b/research/clifford-width-ten-nullity/retained/source7766/retained/three-qubit-PROOF.md new file mode 100644 index 0000000000..9f89ee36a0 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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-width-ten-nullity/retained/source7766/verify.py b/research/clifford-width-ten-nullity/retained/source7766/verify.py new file mode 100644 index 0000000000..ccdf8a4e71 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7766/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()) diff --git a/research/clifford-width-ten-nullity/retained/source7770/CHARACTER-COLUMNS.json b/research/clifford-width-ten-nullity/retained/source7770/CHARACTER-COLUMNS.json new file mode 100644 index 0000000000..06766eb983 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7770/CHARACTER-COLUMNS.json @@ -0,0 +1,821 @@ +{ + "table": "S8(2)", + "one_based_rows": [ + 5, + 6, + 9, + 22 + ], + "columns": [ + { + "index": 1, + "centralizer": 47377612800, + "values": [ + 119, + 135, + 595, + 3213 + ] + }, + { + "index": 2, + "centralizer": 185794560, + "values": [ + 63, + 63, + 203, + 693 + ] + }, + { + "index": 3, + "centralizer": 8847360, + "values": [ + 23, + 39, + -13, + -147 + ] + }, + { + "index": 4, + "centralizer": 2949120, + "values": [ + 31, + 31, + 43, + 85 + ] + }, + { + "index": 5, + "centralizer": 737280, + "values": [ + -1, + 15, + -5, + 69 + ] + }, + { + "index": 6, + "centralizer": 147456, + "values": [ + 15, + 15, + -5, + -27 + ] + }, + { + "index": 7, + "centralizer": 49152, + "values": [ + 7, + 7, + -13, + -19 + ] + }, + { + "index": 8, + "centralizer": 4354560, + "values": [ + 35, + 27, + 91, + 189 + ] + }, + { + "index": 9, + "centralizer": 77760, + "values": [ + -1, + 0, + 10, + 0 + ] + }, + { + "index": 10, + "centralizer": 12960, + "values": [ + 5, + 9, + 1, + 9 + ] + }, + { + "index": 11, + "centralizer": 3888, + "values": [ + 2, + 0, + 1, + 0 + ] + }, + { + "index": 12, + "centralizer": 92160, + "values": [ + 11, + 19, + -5, + -35 + ] + }, + { + "index": 13, + "centralizer": 92160, + "values": [ + 19, + 11, + 35, + 37 + ] + }, + { + "index": 14, + "centralizer": 36864, + "values": [ + 11, + 3, + 23, + 9 + ] + }, + { + "index": 15, + "centralizer": 12288, + "values": [ + 3, + 11, + -1, + 1 + ] + }, + { + "index": 16, + "centralizer": 6144, + "values": [ + 7, + -1, + 7, + -7 + ] + }, + { + "index": 17, + "centralizer": 6144, + "values": [ + -1, + 7, + -1, + 17 + ] + }, + { + "index": 18, + "centralizer": 3072, + "values": [ + 3, + 3, + -1, + 9 + ] + }, + { + "index": 19, + "centralizer": 3072, + "values": [ + 7, + 7, + -1, + 1 + ] + }, + { + "index": 20, + "centralizer": 1024, + "values": [ + 3, + 3, + -5, + -3 + ] + }, + { + "index": 21, + "centralizer": 768, + "values": [ + -1, + 3, + 3, + -3 + ] + }, + { + "index": 22, + "centralizer": 512, + "values": [ + 3, + -1, + 3, + -3 + ] + }, + { + "index": 23, + "centralizer": 512, + "values": [ + -1, + 3, + -1, + 1 + ] + }, + { + "index": 24, + "centralizer": 3600, + "values": [ + 9, + 5, + 10, + 8 + ] + }, + { + "index": 25, + "centralizer": 300, + "values": [ + -1, + 0, + 0, + 3 + ] + }, + { + "index": 26, + "centralizer": 69120, + "values": [ + 15, + 15, + 11, + 21 + ] + }, + { + "index": 27, + "centralizer": 13824, + "values": [ + 11, + 3, + 11, + -3 + ] + }, + { + "index": 28, + "centralizer": 4608, + "values": [ + 7, + 7, + -5, + -11 + ] + }, + { + "index": 29, + "centralizer": 4320, + "values": [ + 5, + 9, + -1, + -9 + ] + }, + { + "index": 30, + "centralizer": 1728, + "values": [ + -1, + 0, + 2, + 0 + ] + }, + { + "index": 31, + "centralizer": 1296, + "values": [ + 0, + 0, + 5, + 0 + ] + }, + { + "index": 32, + "centralizer": 1152, + "values": [ + 3, + 3, + -5, + -3 + ] + }, + { + "index": 33, + "centralizer": 864, + "values": [ + 3, + 3, + -1, + -3 + ] + }, + { + "index": 34, + "centralizer": 864, + "values": [ + -1, + 3, + -1, + -3 + ] + }, + { + "index": 35, + "centralizer": 432, + "values": [ + 2, + 0, + 5, + 0 + ] + }, + { + "index": 36, + "centralizer": 288, + "values": [ + -1, + 0, + -2, + 0 + ] + }, + { + "index": 37, + "centralizer": 288, + "values": [ + 1, + 1, + 1, + 1 + ] + }, + { + "index": 38, + "centralizer": 288, + "values": [ + -1, + 3, + 1, + 3 + ] + }, + { + "index": 39, + "centralizer": 288, + "values": [ + 3, + 3, + 1, + 3 + ] + }, + { + "index": 40, + "centralizer": 144, + "values": [ + 0, + 0, + 1, + 0 + ] + }, + { + "index": 41, + "centralizer": 96, + "values": [ + 1, + 1, + -1, + -1 + ] + }, + { + "index": 42, + "centralizer": 42, + "values": [ + 0, + 2, + 0, + 0 + ] + }, + { + "index": 43, + "centralizer": 384, + "values": [ + 5, + 1, + 1, + -1 + ] + }, + { + "index": 44, + "centralizer": 384, + "values": [ + 1, + 5, + 1, + -1 + ] + }, + { + "index": 45, + "centralizer": 128, + "values": [ + 1, + 1, + -3, + -1 + ] + }, + { + "index": 46, + "centralizer": 128, + "values": [ + 1, + 1, + 1, + 3 + ] + }, + { + "index": 47, + "centralizer": 32, + "values": [ + 1, + -1, + -1, + 1 + ] + }, + { + "index": 48, + "centralizer": 32, + "values": [ + -1, + 1, + 1, + -1 + ] + }, + { + "index": 49, + "centralizer": 54, + "values": [ + 2, + 0, + 1, + 0 + ] + }, + { + "index": 50, + "centralizer": 27, + "values": [ + -1, + 0, + 1, + 0 + ] + }, + { + "index": 51, + "centralizer": 240, + "values": [ + 3, + 3, + -2, + -2 + ] + }, + { + "index": 52, + "centralizer": 240, + "values": [ + 3, + -1, + 2, + -2 + ] + }, + { + "index": 53, + "centralizer": 80, + "values": [ + 1, + 1, + -2, + 0 + ] + }, + { + "index": 54, + "centralizer": 20, + "values": [ + -1, + 0, + 0, + -1 + ] + }, + { + "index": 55, + "centralizer": 1152, + "values": [ + -1, + 3, + -1, + 9 + ] + }, + { + "index": 56, + "centralizer": 576, + "values": [ + 5, + 1, + 7, + 1 + ] + }, + { + "index": 57, + "centralizer": 576, + "values": [ + 1, + 5, + -1, + 1 + ] + }, + { + "index": 58, + "centralizer": 384, + "values": [ + 3, + -1, + -1, + 1 + ] + }, + { + "index": 59, + "centralizer": 144, + "values": [ + -1, + 0, + 2, + 0 + ] + }, + { + "index": 60, + "centralizer": 144, + "values": [ + -1, + 1, + 1, + 1 + ] + }, + { + "index": 61, + "centralizer": 144, + "values": [ + 1, + -1, + -1, + 1 + ] + }, + { + "index": 62, + "centralizer": 96, + "values": [ + 1, + 1, + -1, + 1 + ] + }, + { + "index": 63, + "centralizer": 72, + "values": [ + 2, + 0, + -1, + 0 + ] + }, + { + "index": 64, + "centralizer": 48, + "values": [ + 1, + -1, + 1, + -1 + ] + }, + { + "index": 65, + "centralizer": 48, + "values": [ + -1, + 1, + -1, + -1 + ] + }, + { + "index": 66, + "centralizer": 24, + "values": [ + 0, + 0, + -1, + 0 + ] + }, + { + "index": 67, + "centralizer": 24, + "values": [ + -1, + 0, + 0, + 0 + ] + }, + { + "index": 68, + "centralizer": 14, + "values": [ + 0, + 0, + 0, + 0 + ] + }, + { + "index": 69, + "centralizer": 90, + "values": [ + 0, + 2, + 1, + -1 + ] + }, + { + "index": 70, + "centralizer": 90, + "values": [ + 0, + -1, + 1, + -1 + ] + }, + { + "index": 71, + "centralizer": 15, + "values": [ + -1, + 0, + 0, + 0 + ] + }, + { + "index": 72, + "centralizer": 17, + "values": [ + 0, + -1, + 0, + 0 + ] + }, + { + "index": 73, + "centralizer": 17, + "values": [ + 0, + -1, + 0, + 0 + ] + }, + { + "index": 74, + "centralizer": 18, + "values": [ + 0, + 0, + -1, + 0 + ] + }, + { + "index": 75, + "centralizer": 40, + "values": [ + 1, + -1, + 0, + 0 + ] + }, + { + "index": 76, + "centralizer": 40, + "values": [ + -1, + 1, + 0, + 2 + ] + }, + { + "index": 77, + "centralizer": 21, + "values": [ + 0, + -1, + 0, + 0 + ] + }, + { + "index": 78, + "centralizer": 48, + "values": [ + -1, + 1, + 1, + -1 + ] + }, + { + "index": 79, + "centralizer": 48, + "values": [ + 1, + -1, + 1, + -1 + ] + }, + { + "index": 80, + "centralizer": 30, + "values": [ + 0, + 0, + 1, + 1 + ] + }, + { + "index": 81, + "centralizer": 30, + "values": [ + 0, + -1, + -1, + 1 + ] + } + ] +} diff --git a/research/clifford-width-ten-nullity/retained/source7770/CREDITS.md b/research/clifford-width-ten-nullity/retained/source7770/CREDITS.md new file mode 100644 index 0000000000..59a5eaf699 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7770/CREDITS.md @@ -0,0 +1,40 @@ +# Sources and credit + +Ali Romman (@aliromman) prepared the new restriction proof, exact +checker and package with substantial OpenAI Codex assistance. +New material is Apache-2.0. No independent human or formal +proof-kernel acceptance is claimed. + +Ali Romman's [PR #7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766) +supplied the [width-eleven quotient, width-twelve lower bound and open question](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/PROOF.md), +[exact multiplicities and literal gate routines](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/verify.py) +and source closure. All eighteen files remain byte-exact under +`retained/source7766/`. Its complete registered scientific verifier +runs unchanged. The new checker reuses its literal gate and Pauli +conventions and exact quotient multiplicity routine. + +Nick Petalas (@petalas) supplied the [width-nine quotient proof](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/README.md), +[81-row projection](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/PROJECTION.json) +and [archive reader and table parser](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/verify.py) +in [PR #7747](https://github.com/CrocSwap/integer-mult-bounds/pull/7747). +The new four-row extractor follows that parser's record and row order, +and reuses its archive authentication. Its original replay remains +in the retained closure. + +alephnan (@alephnan) supplied the +[Pauli-sector and quotient framework](https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md) +in [PR #6714](https://github.com/CrocSwap/integer-mult-bounds/pull/6714), +with the stated OpenAI Codex assistance. All notices and prior credit +remain intact. The full three-qubit suite is not rerun here. + +The ordinary S8(2) character table credits the ATLAS. The exact release +is [Thomas Breuer's CTblLib 1.3.11](https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/ctbllib-1.3.11.tar.gz). +`EXTERNAL.json` pins its archive, table member and derived columns. +The table is a mathematical input; authentication and projection do +not reconstruct it from group multiplication. The restriction test +uses classical induction and Frobenius reciprocity. No new general +character theory or global literature priority is claimed. + +Source commits are content pins, not ancestry claims. `SOURCES.json` +records canonical main provenance, and `SOURCE-PINS.json` authenticates +all eighteen retained files. diff --git a/research/clifford-width-ten-nullity/retained/source7770/EXTERNAL.json b/research/clifford-width-ten-nullity/retained/source7770/EXTERNAL.json new file mode 100644 index 0000000000..9f66f6a8ca --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7770/EXTERNAL.json @@ -0,0 +1,13 @@ +{ + "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": "Four complete rational character rows across all 81 classes, including fixed-vector-free classes 9 and 25.", + "verification": "Archive and member authenticated. Complete retained projection and the new four-row extraction are reproduced; the table is not rebuilt from group multiplication.", + "derived_file": "CHARACTER-COLUMNS.json", + "derived_sha256": "9b41c7569bb4c425a53eaec10ccba3eb33a7e8d595bbdf9be2041efb073eb384" +} diff --git a/research/clifford-width-ten-nullity/retained/source7770/PROOF.md b/research/clifford-width-ten-nullity/retained/source7770/PROOF.md new file mode 100644 index 0000000000..0d80447ace --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7770/PROOF.md @@ -0,0 +1,188 @@ +# The full width-twelve nullity + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. + +Use the full four-qubit Gaussian-dyadic Clifford group G, its natural +16-dimensional representation V, its Pauli subgroup P and scalar +kernel Z of order four. These are the exact conventions in +[PR #7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766). +Put S=G/P=Sp(8,2), E=P/Z and N=|G/Z|=12,128,668,876,800. + +For the normalized projective Gram matrix at tensor width twelve, + +```text +nullity H12 = 10,677,394, +rank H12 = 12,128,658,199,406. +``` + +The only absent irreducible modules are the inflated S rows 9 and 22, +of degrees 595 and 3213. Every module with a nontrivial Pauli character +occurs. This makes the source lower bound exact. The threshold T(4)=13 +is unchanged. No physical supplier or new kappa follows. + +## 1. The width-eleven source and the two Pauli orbits + +The [pinned source proof, Section 7](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/PROOF.md) +gives honest quotient modules W11 and W13 with + +```text +V^(tensor 11) = conjugate(V) tensor W11, +V^(tensor 12) = End(V) tensor W11. +``` + +It computes every W11 multiplicity from the ordinary S character +table. Exactly rows 9 and 22 are absent. Their degrees are 595 and +3213. All 79 other rows have positive multiplicity. We retain and +replay that computation unchanged. + +For v in E, let D_v be the Hermitian Pauli matrix. Its line in End(V) +has P character + +```text +lambda_v(D_a) = (-1)^(omega(a,v)), +``` + +where omega is the nondegenerate binary symplectic form. The 256 lines +are distinct and span End(V). G permutes their labels by the ordinary +linear S action. There are two label orbits: {0} and the 255 nonzero +vectors. This is a linear action, not the affine quadratic-form action +that occurs in the central-character-minus-one sector. + +Fix v!=0. Let H be its stabilizer in S and T its preimage in G. +Conjugation by T preserves the actual line C D_v. Its scalar action +eta_v is therefore a one-dimensional character of T that extends +lambda_v. It can have a negative sign; it must not be replaced by a +trivial extension. Since W11 is trivial on P, the lambda_v weight +space of the width-twelve module is + +```text +eta_v tensor Res_H(W11). (1) +``` + +For each irreducible H module rho, the module + +```text +Ind_T^G(eta_v tensor rho) (2) +``` + +is irreducible. To see this, decompose it into its distinct P weight +spaces. A G-invariant subspace restricts on one weight to a +T-invariant subspace of eta_v tensor rho, hence to zero or the whole +space. Transitivity then gives zero or the whole induced module. +Conversely, any irreducible G module on this nonzero P orbit has this +form: take one weight space and divide its T action by eta_v. The +result factors through H, is irreducible, and induction recovers the +original module. Their squared dimensions sum to 255^2 |H|=255|S|. +Together with the quotient sector of size |S|, this accounts for all +256|S| dimensions of the central-character-one regular algebra. +Thus (1) contains all modules in (2) precisely when +Res_H(W11) contains every irreducible H module. This argument does +not assume that G/Z splits over S. + +## 2. A restriction test using classes outside all conjugates of H + +Let S be any finite group, H a subgroup and W a complex S module. +Suppose that its only absent irreducibles are chi_1,...,chi_r. +Choose classes C_j that meet no conjugate of H. If the matrix + +```text +M_(j,i) = chi_i(C_j) +``` + +has column rank r, then Res_H(W) contains every irreducible H module. + +Indeed, if rho were absent, Frobenius reciprocity would make every +constituent of Ind_H^S(rho) absent from W. Its character would be +sum_i a_i chi_i, with nonnegative integer a_i. An induced character +vanishes on every chosen class, because no conjugate of that class +lies in H. Thus M a=0. Full column rank forces a=0, contrary to +Ind_H^S(rho) having positive dimension. This is a direct application +of induction and reciprocity, not a claim of new general character +theory. + +For a nonzero-vector stabilizer in S, the required classes are exactly +those that fix no nonzero vector in E. A class meets some conjugate +of H if and only if it fixes such a vector. + +## 3. Two authenticated class columns settle the restriction + +Use the ordinary S8(2) table in CTblLib 1.3.11, in its published row +and column order. The source identifies the action on all 256 vectors +with character 2+chi_5+chi_6; the two degrees are 119 and 135. +The following exact entries come from the authenticated table member. + +| Class column | Centralizer order | chi_5 | chi_6 | Fixed vectors, including zero | chi_9 | chi_22 | +| --- | --- | --- | --- | --- | --- | --- | +| 9 | 77,760 | -1 | 0 | 1 | 10 | 0 | +| 25 | 300 | -1 | 0 | 1 | 0 | 3 | + +The new checker reads all four rational rows across all 81 classes. +It verifies these two columns, all ordinary inner products and all +nine fixed-dimension bins against the retained source projection. +The two classes are outside every conjugate of H. On the two missing +rows they give diag(10,3), with determinant 30. Section 2 therefore +proves that Res_H(W11) contains every irreducible H module. Equation +(1) and the classification in Section 1 prove that every nonzero +Pauli-character sector occurs at width twelve. + +For v=0, the Pauli line is the scalar identity and eta_0 is trivial. +The entire P-invariant part of End(V) tensor W11 is W11. Hence the +only missing G modules are exactly the inflated rows 9 and 22. + +## 4. Exact nullity and a nullspace projector + +At width twelve, Z acts trivially. The projective Gram matrix is the +central convolution matrix of the character of the tensor power, +up to its positive normalization. For an irreducible module of degree +e, its regular block has dimension e^2 and has a positive Gram +eigenvalue exactly when that module occurs. Thus + +```text +nullity H12 = 595^2 + 3213^2 = 10,677,394, +rank H12 = N - 10,677,394 = 12,128,658,199,406. +``` + +There is also an exact implicit orthogonal projector onto the entire +nullspace. For projective group representatives g_a,g_b, let +s_a,s_b be their images in S. Put + +```text +Q_(a,b) = [595 chi_9(s_a^(-1)s_b) + + 3213 chi_22(s_a^(-1)s_b)] / N. +``` + +Both characters are real. Character orthogonality gives Q^2=Q and +Q*=Q; its trace is 10,677,394. Both modules are absent, so H12 Q=0. +The exact nullity above shows that this is the complete nullspace +projector. The formula does not require a chosen phase for g_a. +No N-by-N matrix or full group enumeration was materialized. + +## Evidence and limits + +The CTblLib release archive and table member pass their retained +SHA-256 pins. The optional archive replay reconstructs all four new +rows and all 81 columns, and reruns the original 81-row projection. +The published character table is a mathematical input. These checks +do not reconstruct it from group multiplication. + +Literal checks use all 65,536 Pauli character pairs and all 1,048,576 +nonzero matrix entries in those conjugations. For all twenty legal +Clifford generators, they compute 5,120 adjoint images, their actual +signs, linear label maps and symplectic action. A separate orbit walk +has sizes 1 and 255. The nonzero stabilizer order is 185,794,560. +The Gaussian Hadamard prefactor cancels with its conjugate; the +quadratic-sector prefactor would give the wrong calculation here. + +Changed character values fail full row orthogonality. The identity +class fails the no-nonzero-fixed-vector condition. Repeated witness +columns fail the rank test. A literal Pauli with negative action on +the selected line rejects the trivial-extension substitution. + +The general induction argument is written mathematics. Finite gate +checks support the exact conventions; they do not replace the proof. +Full width-ten nullity, sharp conditioning, native realization and +complete caller pricing remain open. The source threshold T(4)=13, +all five framework assumptions and the selected frontier remain +unchanged. No selected cold replay, full three-qubit suite, Lean, +Docker, independent human acceptance or formal proof kernel was used. +No global literature priority is claimed. diff --git a/research/clifford-width-ten-nullity/retained/source7770/README.md b/research/clifford-width-ten-nullity/retained/source7770/README.md new file mode 100644 index 0000000000..5d387f2801 --- /dev/null +++ b/research/clifford-width-ten-nullity/retained/source7770/README.md @@ -0,0 +1,44 @@ +# Exact four-qubit width-twelve nullity + +The full Gaussian-dyadic four-qubit Clifford Gram matrix at tensor +width twelve has exact nullity 10,677,394 and exact rank +12,128,658,199,406. Only inflated Sp(8,2) rows 9 and 22 are absent. +Every nonzero Pauli-character sector occurs. The threshold T(4)=13 +is unchanged; no new kappa follows. + +Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json), +[CHARACTER-COLUMNS.json](CHARACTER-COLUMNS.json), [verify.py](verify.py), +[SOURCE-PINS.json](SOURCE-PINS.json), [EXTERNAL.json](EXTERNAL.json) +and [CREDITS.md](CREDITS.md). The proof also gives an implicit +orthogonal projector onto the complete nullspace. + +Run with Python 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-width-twelve-nullity +``` + +Both registered modes print `PASS_CLIFFORD_WIDTH_TWELVE_NULLITY`. +To reproduce the new columns from the authenticated release archive, +run this additional command after obtaining the file in EXTERNAL.json: + +```sh +python3.12 -B research/clifford-width-twelve-nullity/verify.py \ + --ctbllib-archive /path/to/ctbllib-1.3.11.tar.gz +``` + +That command also prints +`PASS_AUTHENTICATED_CTBL_COLUMNS classes=81 rational_rows=4`. +It authenticates and replays the source projection. The registered +commands use the retained columns and need no network access. + +## Open next questions + +- Determine the full nullity at width ten. Its quadratic Pauli orbits + need a different restriction calculation from the linear orbit here. +- Determine exact spectral endpoints or a useful conditioning bound + at width thirteen. Support alone does not give those quantities. +- Connect the alphabet to native operations and complete caller costs. + This package gives an algebraic dependence result, not a supplier. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/clifford-width-ten-nullity/verify.py b/research/clifford-width-ten-nullity/verify.py new file mode 100644 index 0000000000..c72b0e11da --- /dev/null +++ b/research/clifford-width-ten-nullity/verify.py @@ -0,0 +1,227 @@ +"""Check both quadratic sectors of the four-qubit width-ten Gram matrix. + +Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. +""" +import argparse +from collections import Counter +from hashlib import sha1, sha256 +import importlib.util +import json +from math import prod +from pathlib import Path +import subprocess +import sys + +ROOT = Path(__file__).resolve().parent +ORDER = 47_377_612_800 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def load(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def source_check(archive): + 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'], 'source SHA256') + require(sha1(b'blob '+str(len(raw)).encode()+b'\0'+raw).hexdigest() == pin['git_blob'], + 'source Git blob') + path = ROOT/'retained/source7766' + args = [sys.executable, '-W', 'error', *(['-O'] if sys.flags.optimize else []), + '-B', str(path/'verify.py')] + if archive: + args += ['--ctbllib-archive', str(archive)] + result = subprocess.run(args, check=True, capture_output=True, text=True, timeout=60) + require('PASS_CLIFFORD_FOUR_QUBIT_THRESHOLD' in result.stdout, 'unchanged source replay') + return len(pins), load('source7766', path/'verify.py'), load('source7747', path/'retained/source7747/verify.py') + + +def gaussian(n, r): + return prod(2**n-2**i for i in range(r))//prod(2**r-2**i for i in range(r)) + + +def quadratic_tuple_orbits(n, length, minus): + total = 0 + for r in range(min(length, 2*n)+1): + for t in range(r % 2, r+1, 2): + if r+t > 2*n: + continue + even, half = r-t, (r-t)//2 + gl = prod(2**even-2**i for i in range(even)) + sp = 2**(half*half)*prod(2**(2*i)-1 for i in range(1, half+1)) + alternating = gaussian(r, t)*gl//sp + if r+t < 2*n: + forms = 2**r + else: + zero_radical = ((2**(2*half)+(-1 if minus else 1)*2**half)//2 + if half else int(not minus)) + forms = (2**t-1)*2**even+zero_radical + total += gaussian(length, r)*alternating*forms + return total + + +def small_group_orbits(source): + records = [] + for n in (1, 2): + for minus in (False, True): + width, size = 2*n, 2**(2*n) + q = [source.quadratic(x, n, minus) for x in range(size)] + group = [] + + def extend(columns, span): + if len(columns) == width: + group.append(tuple(columns)) + return + index = len(columns) + for v in range(1, size): + if v in span or q[v] != q[1 << index]: + continue + if any(source.omega(v, w, n) != source.omega(1 << index, 1 << j, n) + for j, w in enumerate(columns)): + continue + extend(columns+[v], span | {x ^ v for x in span}) + + extend([], {0}) + expected_order = 2**(n*(n-1)+1)*(2**n+(1 if minus else -1))*prod(2**(2*i)-1 for i in range(1, n)) + require(len(group) == expected_order, 'complete small orthogonal group') + fixed = [] + for columns in group: + images = [source.apply(columns, x) for x in range(size)] + require(len(set(images)) == size and all(q[x] == q[y] for x, y in enumerate(images)), + 'literal small quadratic action') + fixed.append(sum(x == y for x, y in enumerate(images))) + moments = [] + for length in range(9): + total = sum(f**length for f in fixed) + value, remainder = divmod(total, len(group)) + require(remainder == 0 and value == quadratic_tuple_orbits(n, length, minus), + 'independent small-group orbit formula') + moments.append(value) + records.append({'half_dimension': n, 'minus': minus, 'group_order': len(group), + 'tuple_orbits_0_to8': moments}) + return records + + +def check_group(group, sdata, degrees, quotient_multiplicities): + minus = group['kind'] == 'minus' + index = 120 if minus else 136 + order = group['order'] + centralizers, fusion, rows = group['centralizers'], group['fusion_to_S8'], group['rows'] + require(order*index == ORDER and len(centralizers) == len(fusion) == len(rows), 'stabilizer size') + require(fusion[0] == 1 and centralizers[0] == order, 'identity fusion') + require(all(c > 0 and order % c == 0 for c in centralizers), 'stabilizer centralizers') + sizes = [order//c for c in centralizers] + require(sum(sizes) == order, 'stabilizer class-size sum') + masses = [0]*81 + dims = [] + for size, target in zip(sizes, fusion, strict=True): + require(1 <= target <= 81, 'fusion target') + masses[target-1] += size + point = sdata['columns'][target-1] + fixed = 2+sum(point['values'][:2]) + require(fixed.bit_count() == 1, 'fixed-space power') + dims.append(fixed.bit_length()-1) + for mass, column in zip(masses, sdata['columns'], strict=True): + actual, remainder = divmod(column['centralizer']*mass, order) + expected = 1+column['values'][0 if minus else 1] + require(remainder == 0 and actual == expected, 'quadratic-form fusion character') + require(dims.count(8) == 1 and dims[0] == 8, 'identity fixed dimension') + multiplicities, restriction_degrees = [], [0]*81 + for i, row in enumerate(rows): + degree = row['degree'] + require(type(degree) is int and degree > 0 and len(row['sums_d1_to7']) == 7, 'stabilizer row') + numerator = degree*(2**32-1)+sum(a*(2**(4*d)-1) for d, a in enumerate(row['sums_d1_to7'], 1)) + value, remainder = divmod(numerator, order) + require(remainder == 0, 'nonintegral stabilizer multiplicity') + value += i == 0 + require(value >= 0, 'negative stabilizer multiplicity') + restriction = row['restriction'] + require([j for j, _ in restriction] == sorted({j for j, _ in restriction}), 'restriction row indices') + require(all(1 <= j <= 81 and type(b) is int and b > 0 for j, b in restriction), 'restriction coefficients') + require(sum(degrees[j-1]*b for j, b in restriction) == index*degree, 'induced dimension') + require(sum(quotient_multiplicities[j-1]*b for j, b in restriction) == value, + 'independent quotient restriction multiplicity') + for j, b in restriction: + restriction_degrees[j-1] += degree*b + multiplicities.append(value) + require(restriction_degrees == degrees, 'all restricted quotient dimensions') + require(sum(r['degree']**2 for r in rows) == order, 'stabilizer regular dimension') + require(sum(r['degree']*m for r, m in zip(rows, multiplicities, strict=True)) == 2**32, + 'whole quotient restriction dimension') + norm = quadratic_tuple_orbits(4, 8, minus) + require(sum(m*m for m in multiplicities) == norm, 'independent quadratic tuple norm') + require(sum(size*2**(8*d) for size, d in zip(sizes, dims, strict=True)) == order*norm, + 'class histogram tuple norm') + require(multiplicities[0] == quadratic_tuple_orbits(4, 4, minus), 'four-tuple orbit count') + require(multiplicities[1] == int(not minus), 'source Dickson multiplicity') + missing = [{'row': i+1, 'degree': row['degree'], 'clifford_degree': index*row['degree']} + for i, (row, m) in enumerate(zip(rows, multiplicities, strict=True)) if m == 0] + loss = sum(row['clifford_degree']**2 for row in missing) + return {'kind': group['kind'], 'index': index, 'order': order, 'multiplicities': multiplicities, + 'missing': missing, 'nullity': loss, 'tuple_norm': norm, + 'four_tuple_orbits': multiplicities[0], 'class_dimension_counts': dict(sorted(Counter(dims).items()))} + + +def collect(archive=None): + count, source, old = source_check(archive) + external = json.loads((ROOT/'EXTERNAL.json').read_text()) + raw = (ROOT/'STABILIZERS.json').read_bytes() + require(sha256(raw).hexdigest() == external['derived_sha256'], 'derived stabilizer hash') + data = json.loads(raw) + if archive: + extractor = load('exact_table_extractor', ROOT/'extract.py') + require(extractor.extract(archive) == data, 'authenticated complete stabilizer extraction') + sdata = json.loads((ROOT/'retained/source7770/CHARACTER-COLUMNS.json').read_text()) + projection = json.loads((ROOT/'retained/source7766/retained/source7747/PROJECTION.json').read_text()) + degrees, multiplicities = old.check_projection(projection) + groups = [check_group(g, sdata, degrees, multiplicities) for g in data['groups']] + require([g['kind'] for g in groups] == ['minus', 'plus'], 'both quadratic sectors') + require([[m['row'] for m in g['missing']] for g in groups] + == [[2, 4, 10, 14, 22, 28, 43], [4, 6, 14, 16, 21, 25, 44, 46]], 'full missing-row profile') + require([g['nullity'] for g in groups] == [102154809600, 91765092608], 'sector nullities') + for fault, reason in [('fusion', 'identity fusion'), ('sum', 'nonintegral stabilizer multiplicity')]: + bad = json.loads(json.dumps(data['groups'][0])) + if fault == 'fusion': + bad['fusion_to_S8'][0] = 2 + else: + bad['rows'][0]['sums_d1_to7'][0] += 1 + try: + check_group(bad, sdata, degrees, multiplicities) + except ValueError as error: + require(str(error) == reason, 'wrong fault rejection') + else: + raise ValueError('stabilizer fault accepted') + dimension = sum(g['index']**2*g['order'] for g in groups) + nullity = sum(g['nullity'] for g in groups) + require(dimension == 256*ORDER and nullity == 193919902208, 'complete central ideal') + return {'source_files': count, 'groups': groups, 'small_group_checks': small_group_orbits(source), + 'projective_order': dimension, 'exact_nullity': nullity, 'exact_rank': dimension-nullity, + 'archive_validation_scope': data['archive_checks'], 'threshold': 'T(4)=13 unchanged'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--ctbllib-archive', type=Path) + args = parser.parse_args() + result = collect(args.ctbllib_archive) + require(json.loads(json.dumps(result)) == json.loads((ROOT/'RESULT.json').read_text()), 'saved result mismatch') + if args.ctbllib_archive: + print('PASS_AUTHENTICATED_STABILIZERS rows=127 inner_products=14650 restrictions=10287') + print('PASS_CLIFFORD_WIDTH_TEN_NULLITY') + print('Exact nullity 193919902208; exact rank 11934748974592; T(4)=13 unchanged') + print('Minus: seven missing modules, nullity 102154809600; plus: eight, nullity 91765092608') + print('All 127 multiplicities agree with quotient restrictions; complete regular dimension passes') + print('Independent quadratic tuple norms 78491573017 and 84713186558; four complete small groups') + + +if __name__ == '__main__': + main()