From 7efc2c67b32e305d20e484dc3afa9229ab119269 Mon Sep 17 00:00:00 2001 From: apoursh <8867770+apoursh@users.noreply.github.com> Date: Thu, 19 Nov 2026 12:44:59 -0500 Subject: [PATCH] Prove sharp polynomial pass bounds for width-13 Clifford decoding --- .../PROOF.md | 70 + .../README.md | 31 + .../SCHEDULE.json | 271 +++ .../SOURCE-PINS.json | 28 + .../SOURCES.json | 55 + .../TASK.json | 93 + .../VERIFY.json | 63 + .../independent.py | 148 ++ .../sources/sp8-projection.json | 87 + .../sources/width13-spectrum.json | 1519 +++++++++++++++++ .../verify.py | 186 ++ 11 files changed, 2551 insertions(+) create mode 100644 research/clifford-accelerated-dyadic-decoder/PROOF.md create mode 100644 research/clifford-accelerated-dyadic-decoder/README.md create mode 100644 research/clifford-accelerated-dyadic-decoder/SCHEDULE.json create mode 100644 research/clifford-accelerated-dyadic-decoder/SOURCE-PINS.json create mode 100644 research/clifford-accelerated-dyadic-decoder/SOURCES.json create mode 100644 research/clifford-accelerated-dyadic-decoder/TASK.json create mode 100644 research/clifford-accelerated-dyadic-decoder/VERIFY.json create mode 100644 research/clifford-accelerated-dyadic-decoder/independent.py create mode 100644 research/clifford-accelerated-dyadic-decoder/sources/sp8-projection.json create mode 100644 research/clifford-accelerated-dyadic-decoder/sources/width13-spectrum.json create mode 100644 research/clifford-accelerated-dyadic-decoder/verify.py diff --git a/research/clifford-accelerated-dyadic-decoder/PROOF.md b/research/clifford-accelerated-dyadic-decoder/PROOF.md new file mode 100644 index 0000000000..7924b17657 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/PROOF.md @@ -0,0 +1,70 @@ +# Two finite schedules at tensor width 13 + +Let $R=\mathbb Z[i,1/2]$. For one Gaussian-dyadic unitary $U_a$ in each projective four-qubit Clifford class, let $A$ have columns $(\operatorname{vec}(U_a)/4)^{\otimes13}$. There are $N=12,128,668,876,800$ columns. Write $K=A^*A$, $J=K^{-1}A^*$, and use the Euclidean operator norm. The width-13 spectrum gives **52 distinct positive rational levels** $x_0<\cdots0$, the factors $|1-h_jx|$ are at most one until $h_jx>2$, and at least one thereafter. Prefix products have their maximum at an endpoint. The final product at each node is at most one, so **every prefix has norm at most one** as an operator on the initial error. The order matters numerically even in this finite example. Applying the same 52 factors in reverse gives a prefix norm strictly between $2^{138}$ and $2^{139}$ at step 48. + +### A coefficient bound for writing out the decoder + +The nominal $b_x$ range from 69 to 266 with sum 5,676. Reducing each $h_x$ gives a total denominator exponent of 5,627. This counts dyadic scalar coefficients. To bound coefficients in the full decoder, the stabilizer-state result $4U_a\in\mathbb Z[i]^{16\times16}$ gives $2^{52}A$ integral. Also $K(a,b)=(\operatorname{tr}(U_a^*U_b)/16)^{13}$. The relative Clifford has finite order, and its Gaussian-rational trace, a sum of roots of unity, is a Gaussian integer. Thus $2^{52}K$ is integral. [Stabilizer entry bound, PR 7802 §4](https://github.com/apoursh/integer-mult-bounds/blob/ebe2c019e398d73444e4f33f2d71bd5775795a01/research/clifford-dyadic-noise-floor/PROOF.md) + +For the explicit initial Bell inverse of PR 7799, $2^{27}B$ is integral. Indeed its normalization multiplier $4^{13}$ and the six Bell bras and six Bell kets with entries of denominator four leave the factor $4^{13}/4^{12}=4$. The Weyl permutations and phase corrections are integral. Isolating a fibre costs at most $2^{23}$ in the denominator, through two shear-character averages of order $2^{10}$ and a coset average of order eight. The terminal coefficient comes from $U_a^*/16$, with denominator dividing $2^6$. The scalar ledger gives the exponent $23+6-2=27$. Adding the exponents under the 52 updates therefore places every coefficient of every prefix on the $2^{-8358}\mathbb Z[i]$ grid, since $27+52\cdot52+5627=8358$. This is a sufficient common grid. Movement, accumulator headroom, and a gate count for $A^*$ and $K$ require a concrete implementation. [Bell maps and averages, PR 7799 §§1–4](https://github.com/apoursh/integer-mult-bounds/blob/7f08a74037788311cc6b7da27297b25f1b188e45/research/clifford-bell-fibres/PROOF.md) + +## 2. Exact optimum with 50 dyadic steps and one odd reciprocal + +Construct a real polynomial $r$ of degree at most 50 by prescribing at the 51 nonbottom nodes +$$ +r(x_j)=(-1)^{j-1}/(1-x_j/x_0),\qquad 1\le j\le51. +$$ +Its values alternate strictly, so it has one simple real root in each open interval $(x_j,x_{j+1})$, $1\le j\le50$, and degree exactly 50. For each root $z$ use the scalar $2^{-192}\lfloor 2^{192}/z\rfloor$, in order of decreasing root. Complete the sequence by the exact factor $h=1/x_0=2^{32}/470624175$. These steps approximate the normalized polynomial $(1-X/x_0)r(X)/r(0)$, chosen to vanish on the bottom level and equioscillate on the rest. The package rounds reciprocals using only rational interpolation and integer sign comparisons. In particular, its generator never approximates a root in floating point. All 51 factors are listed in SCHEDULE.json. + +Exact substitution of the stored shifts gives $p(x_0)=0$ and $2^{-59}<\max_i|p(x_i)|<2^{-58}$. Set $C=D-J$. The range of $C$ is orthogonal to the bottom eigenspace and $\|C\|<1/4$. On that eigenspace $DD^*=K^{-1}+CC^*$ is exactly $1/x_0$. On its orthogonal complement the largest eigenvalue is at most $1/x_1+1/16<1/x_0$, since the spectral gap $1/x_0-1/x_1$ exceeds three. Hence the exact corrected decoder **attains** $\|D\|^2=1/x_0$. If $B$ is dyadic, all odd denominators enter through the single last scalar. The sharp necessity in PR 7802 then gives the least odd denominator exactly $470,624,175$. This realizes the optimum among left inverses, including noncanonical ones. [Sharp denominator theorem, PR 7802](https://github.com/apoursh/integer-mult-bounds/blob/ebe2c019e398d73444e4f33f2d71bd5775795a01/research/clifford-dyadic-noise-floor/PROOF.md) · [Separate canonical-denominator result, PR 7805](https://github.com/apoursh/integer-mult-bounds/blob/d3df403a13bee082a8cef62f190024aaf0cd08dd/research/clifford-canonical-denominator/PROOF.md) + +## 3. Why the pass counts are sharp in the stated model + +A normalized residual polynomial has $p(0)=1$ and may have complex coefficients. For any $d+1$ distinct positive nodes $X$ and any $p$ of degree at most $d$, Lagrange interpolation at zero gives +$$ +1\le\max_{x\in X}|p(x)|W(X),\qquad W(X)=\sum_{x\in X}\prod_{y\in X,\, y\ne x}|y/(y-x)|. +$$ +The verifier computes the following strict integer bounds. The independent replay uses Newton divided differences on the alternating data $(-1)^i$ in increasing node order, since these are the signs of the Lagrange basis values at zero. + +| Nodes, indexed from zero in increasing order | Certified weight sum | Consequence for the full spectrum | +|---|---:|---| +| All 52 levels | $2^{60}2^{-61}$. | +| All levels except $x_{21}$ | $2^{52}2^{-53}$. | + +Thus 52 is the least degree for contraction by $2^{-128}$. On the full set, the exact degree-51 minimax residual equals $1/W$, attained by interpolation of the alternating signs divided by $W$. This also explains the abrupt gain in the last degree. + +For the second claim, fix a polynomial of degree at most 50 in advance. There is a level $x$ with $|p(x)|>2^{-53}$. Let $u$ be a unit $K$-eigenvector at that level and $v$ a unit ambient vector perpendicular to the columns of $A$. Give the method the initial inverse $B'=J+2^{55}uv^*$. It has $B'A=I$ and admissible error $2^{55}<2^{56}$. Its final error norm exceeds four, so the identity for $DD^*$ forces $\|D\|>4>1/\sqrt{x_0}$. The same strict obstruction holds for some dyadic starting inverse. Indeed choose a dyadic split $L$, put $P=I-AL$, and observe that $B'=L+(B'-L)P$. Approximating $B'-L$ entrywise by a dyadic $H$ gives the exactly feasible $L+HP$ arbitrarily close to $B'$. Continuity preserves both strict bounds. Therefore 51 is the smallest degree of a **fixed normalized residual polynomial guaranteeing the optimal norm for every such initial dyadic left inverse**, when the final odd reciprocal is allowed. + +These are uniform polynomial lower bounds given only a spectral residual or initial norm requirement. The Bell inverse may have additional structure in its error, and more general algorithms may use projections or side information. Neither lower bound prices a physical multiplier. Larger tensor widths require a new spectral check for these node-specific schedules. diff --git a/research/clifford-accelerated-dyadic-decoder/README.md b/research/clifford-accelerated-dyadic-decoder/README.md new file mode 100644 index 0000000000..9b039972ae --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/README.md @@ -0,0 +1,31 @@ +# Sharp polynomial pass counts for the four-qubit Clifford decoder + +At tensor width 13, **52 applications of the Gram matrix suffice for a Gaussian-dyadic left inverse within $2^{-73}$ of the canonical decoder** in operator norm. The previous explicit construction used 8,192 applications of a fixed step and also covered larger widths. The 52-step schedule uses the exact discrete width-13 spectrum. Every prefix recovers noiseless inputs exactly and amplifies the initial error relative to the canonical decoder by at most one. [Derivation, lower certificates and coefficient bounds](PROOF.md) · [Complete scalar schedules](SCHEDULE.json) · [Previous uniform construction, PR 7799 §5](https://github.com/apoursh/integer-mult-bounds/blob/7f08a74037788311cc6b7da27297b25f1b188e45/research/clifford-bell-fibres/PROOF.md) + +| Goal at width 13 | Exact scalar arithmetic | Gram applications | Lower certificate | +|---|---|---:|---| +| Contract the initial error uniformly by at least $2^{-128}$ | All 52 steps dyadic, actual residual below $2^{-129}$ | **52** | Every normalized polynomial of degree at most 51 has residual above $2^{-61}$. | +| Attain the optimal squared noise norm $2^{32}/470624175$ | 50 dyadic steps on a 192-bit grid, then one multiplication by $2^{32}/470624175$ | **51** | Every fixed normalized polynomial of degree at most 50 fails for some exact dyadic initial inverse within the stated error bound. | + +For observation $y$, initialize $d=By$ with the Bell inverse and precompute $t=A^*y$. Each listed scalar $h$ prescribes the update $d\gets d+h(t-Kd)$ with $K=A^*A$. Only the second schedule uses odd division, and its denominator realizes the previously proved sharp minimum among all optimal-norm decoders. The scalar precisions of the first schedule range from 69 to 266 fractional bits. The proof gives a sufficient grid for writing out every coefficient of that decoder. [Sharp arithmetic necessity, PR 7802](https://github.com/apoursh/integer-mult-bounds/blob/ebe2c019e398d73444e4f33f2d71bd5775795a01/research/clifford-dyadic-noise-floor/PROOF.md) + +Both lower bounds concern fixed residual polynomials $p$ with $p(0)=1$. The second uses only the hypothesis $\|B-J\|<2^{56}$ about the initial error and allows other exact dyadic starting inverses besides the Bell inverse. The 52-level program counts exact Gram applications. Producing the input, pricing an individual application and realizing a multiplication supplier remain open. No change to the selected multiplication exponent is claimed. + +## Reproduce + +From the repository root, use CPython 3.12 and the standard library. + +~~~sh +python3.12 -B scripts/research_package.py --package research/clifford-accelerated-dyadic-decoder +~~~ + +The primary verifier regenerates the shifts from Ali Romman's spectrum using rational interpolation, integer root comparisons and explicit rounding. It checks both schedules and both degree lower bounds. The second verifier recovers the levels from Nick Petalas's fixed-space character projections. It checks integer prefix products, computes the lower certificates using divided differences and applies the actual updates to a rectangular dyadic test with a nondiagonal Gram matrix. Reversing the 52 shifts gives an intermediate amplification above $2^{138}$, which the prescribed order avoids. The generator supports writing a fresh copy of SCHEDULE.json via its `--emit-schedule` option. [Source pins](SOURCE-PINS.json) · [Registered checks](VERIFY.json) + +## Credit + +Ali Romman supplied the four-qubit spectrum and conditioning. Nick Petalas supplied the projected quotient character data from the ATLAS and Thomas Breuer's GAP Character Table Library. The four-qubit Clifford conventions also build on alephnan's Pauli-sector work. The starting dyadic splitting, the sharp optimal-noise denominator, and the separate larger arithmetic cost of the canonical inverse are earlier contributions of apoursh. The present results use classical Lagrange interpolation, alternation and spectral polynomial iteration. Prepared by **apoursh** with substantial OpenAI Codex assistance. Apache-2.0. [Source files and predecessor credits](SOURCE-PINS.json) · [Canonical denominator, PR 7805](https://github.com/apoursh/integer-mult-bounds/blob/d3df403a13bee082a8cef62f190024aaf0cd08dd/research/clifford-canonical-denominator/PROOF.md) · [Investigation claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19755740) + +## Open next questions + +1. Can one Gram application be evaluated on a compact acquisition interface? Start with one specified observation layout and count data movement, arithmetic, and intermediate precision for $K d$. The pass counts leave those costs open. +2. Does the particular Bell inverse already have zero error on any of the 52 levels? Project its error onto the smallest block first. Extra exact zeros could reduce the required polynomial degree for this specific starting matrix. diff --git a/research/clifford-accelerated-dyadic-decoder/SCHEDULE.json b/research/clifford-accelerated-dyadic-decoder/SCHEDULE.json new file mode 100644 index 0000000000..8285a6ed62 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/SCHEDULE.json @@ -0,0 +1,271 @@ +{ + "width": 13, + "target_contraction_bits": 128, + "dyadic_steps_numerator_and_fraction_bits": [ + [ + 16235024724083224395359823436643253233985060541178529464128234987963972511524430, + 266 + ], + [ + 290221599984547371426095893968688576590336715685307957390394351699883619242, + 250 + ], + [ + 20759518831968770215992325737141837234675814767551269797515768913240005, + 236 + ], + [ + 13400269619305904983103956230798591927252828970295216170819282, + 205 + ], + [ + 7768397226843759158361126859959686065355191018524402596, + 184 + ], + [ + 1061846493480964117330722486058983726907763264856036, + 171 + ], + [ + 2253847972392885451668735299675711035638267489260, + 162 + ], + [ + 9479333862502341328575410033896046829000364509, + 154 + ], + [ + 653787064491433453447888997699129206345850, + 140 + ], + [ + 1362056384357153028016435411873185846554, + 131 + ], + [ + 1415035306222108780768404475433412823, + 121 + ], + [ + 712571350633276207458375110843254314, + 120 + ], + [ + 46762494885308751114455866649088564, + 116 + ], + [ + 23670554216410503938700944872991962, + 115 + ], + [ + 798539871675354356462702640865583, + 110 + ], + [ + 405924434768305131201873842440005, + 109 + ], + [ + 6961356541377184033568720621113, + 103 + ], + [ + 113260165950977994196951406931, + 97 + ], + [ + 114349206008198936448845170459, + 97 + ], + [ + 3871197078402568161028612542, + 92 + ], + [ + 995450677303517527121643225, + 90 + ], + [ + 254312216829365791600419802, + 88 + ], + [ + 263945255345629647342859946, + 88 + ], + [ + 69128519257188717161225224, + 86 + ], + [ + 9149362842863212565456280, + 83 + ], + [ + 4713308131171957988265356, + 82 + ], + [ + 1234437843878369949307593, + 80 + ], + [ + 162019967009036055846622, + 77 + ], + [ + 82851119493257074012477, + 76 + ], + [ + 21699102724424471765173, + 74 + ], + [ + 688637327394299945915, + 69 + ], + [ + 689034007882430303027, + 69 + ], + [ + 390583849039640491773106, + 78 + ], + [ + 202524958761295069808277, + 77 + ], + [ + 109363477731099337696470, + 76 + ], + [ + 112095209732995875847372, + 76 + ], + [ + 115728547863597182747587, + 76 + ], + [ + 480408041712839467917308, + 78 + ], + [ + 4166227723089498578913127, + 81 + ], + [ + 8694736117751997034253483, + 82 + ], + [ + 77769584164337306806378377, + 85 + ], + [ + 355518099036970545400586866, + 87 + ], + [ + 100730128060474987863499612, + 85 + ], + [ + 51846389442891537870918918, + 84 + ], + [ + 52883317231749368628337296, + 84 + ], + [ + 3732940039888190726706162094, + 90 + ], + [ + 18294769204497078876830199810, + 92 + ], + [ + 37542711258304089594301973056, + 93 + ], + [ + 3094429534017791627166708082217, + 99 + ], + [ + 7220335579374847130055652191839, + 100 + ], + [ + 15128322166309203510592795068615, + 101 + ], + [ + 23692732315048013780354269170988041, + 111 + ] + ], + "norm_optimal_dyadic_fraction_bits": 192, + "norm_optimal_dyadic_numerators": [ + 859475052549165482811305455414865991096807340106825388339, + 1006908445457488960557756639438044878703595582121840670999, + 1180042024314432763730583572916079744725028306649681283665, + 1635775100012927854382807157079906241119860312465666159069, + 1988709690072002344540448476149679855420345580014595839436, + 2226853497496590860588359323085127324655140945845069625626, + 2420050832895838469497851685375491856984460867244234868387, + 2605659451348026670698277063705720628087769899752830937538, + 2944395180023270137891440807894999855257632379099145086974, + 3140688192024821481250734185478404957577364476881197544901, + 3341157651090236697679284008732529265898007238294727784253, + 3365023062883739289832919340601614758696608769488205562783, + 3533274216027952573601408269431526191899622775000495736272, + 3576993019600871445453897621630767329494563677277007359513, + 3861501875441639064688623446530872220405635135534475142910, + 3925860240033699068783370138970305764806942380655648940162, + 4308870995337672945882011599371528029940173617456835212180, + 4486697423692198676780610232559991091121905813587456595436, + 4529838747941271569452737543360407091661946603023187295012, + 4907325459509328810821638146454873691725959298218977646838, + 5047535680237308533248910324969354099973945328286407362634, + 5158066738588737881820325941297067525390242141957021540956, + 5353449224592715969010896900128972114397364913265099018351, + 5608379470030481761855605647050940201404190474320589201870, + 5938322160935363800225363509023433844364762346129369179457, + 6118332051146203973534367340494825287482716266252038381659, + 6409811831289322535659489818898654358061439211090398633350, + 6731135991661158598837266824277521189352463850364714725037, + 6884641557974267991044803334218883484147107365013904495616, + 7213344523754344775825533276544741454937925477566144918599, + 7325001557730663323134909412091081960144259467234547933398, + 8111112937334618597536788369338758376019944229387072178705, + 8411086109873357754052640672463960544163427143836319367115, + 9080246860286922611003532090070889758818405608839383586839, + 9304126808714028360727181721755904670693932165381353437529, + 9608751371657165987185653790288292582858732240130034076332, + 9975717937056278642922727970213855966377789249804178261065, + 10815737180814123767009785805004756706174379357546545579983, + 11286236022023968138701707926367324667192329654545834731518, + 12618817964264207161824703070914240434142317465873297280369, + 14421518708936486981261060249872627133205108160947709711716, + 16344353101450138227354963240062708338148403296790232790848, + 16825027585504518921673920152093609645268678588979852664594, + 17161568581151902022192938183651136483219073403934938410257, + 18928253234724281370515039404323165067510131582897075095675, + 23191374938146150486938241734086605260978496106837162637434, + 23795520070867650923991499017620479513970449742849056734033, + 30645745749020409104485468038848124112319246785061549906448, + 35753370041986549464346932311634027232400996533638746408163, + 37455911473209746128941962907330832121362126825940680340490 + ], + "norm_optimal_final_reciprocal": [ + 4294967296, + 470624175 + ] +} diff --git a/research/clifford-accelerated-dyadic-decoder/SOURCE-PINS.json b/research/clifford-accelerated-dyadic-decoder/SOURCE-PINS.json new file mode 100644 index 0000000000..d47af13c9d --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/SOURCE-PINS.json @@ -0,0 +1,28 @@ +{ + "files": [ + { + "pr": 7747, + "author": "petalas", + "head": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "path": "research/clifford-four-qubit-width-nine/PROJECTION.json", + "url": "https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/PROJECTION.json", + "use": "Independent recovery of the 81 width-13 eigenvalues from fixed-space character projections.", + "bytes": 7054, + "sha256": "0a36754668b66480e5f968c117a4532bc3a5eaab5c9d8448f14a5d0321c2efae", + "git_blob": "406f84b46901df771050eac3f367413cc6529ba1", + "local_path": "sources/sp8-projection.json" + }, + { + "pr": 7772, + "author": "aliromman", + "head": "1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2", + "path": "research/clifford-threshold-conditioning/RESULT.json", + "url": "https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/RESULT.json", + "use": "Primary full-alphabet width-13 spectral blocks.", + "bytes": 28857, + "sha256": "d032d5e63820f4ffe246d21adcd8d272f04dfd635a6fc519c4a81a366ca41d49", + "git_blob": "039f22ba0bfec63c02fb3a97959766b8ec3a1bfa", + "local_path": "sources/width13-spectrum.json" + } + ] +} diff --git a/research/clifford-accelerated-dyadic-decoder/SOURCES.json b/research/clifford-accelerated-dyadic-decoder/SOURCES.json new file mode 100644 index 0000000000..1dbb3566b4 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/SOURCES.json @@ -0,0 +1,55 @@ +{ + "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" + } + ], + "cited_research": [ + { + "pr": 7747, + "head": "ff12ca358d601a21cd4b1f016b8a3a969ac44016", + "author": "petalas", + "title": "Prove the exact four-qubit Clifford Gram rank at width nine", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7747" + }, + { + "pr": 7772, + "head": "1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2", + "author": "aliromman", + "title": "Determine sharp four-qubit Clifford threshold conditioning", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7772" + }, + { + "pr": 7799, + "head": "7f08a74037788311cc6b7da27297b25f1b188e45", + "author": "apoursh", + "title": "Prove the sharp Gaussian-dyadic four-qubit Clifford tensor width is 13 (no κ)", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7799" + }, + { + "pr": 7802, + "head": "ebe2c019e398d73444e4f33f2d71bd5775795a01", + "author": "apoursh", + "title": "Determine the sharp odd denominator for noise-optimal four-qubit Clifford decoding", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7802" + }, + { + "pr": 7805, + "head": "d3df403a13bee082a8cef62f190024aaf0cd08dd", + "author": "apoursh", + "title": "Determine the exact odd denominator of the canonical width-13 Clifford decoder", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/7805" + } + ] +} diff --git a/research/clifford-accelerated-dyadic-decoder/TASK.json b/research/clifford-accelerated-dyadic-decoder/TASK.json new file mode 100644 index 0000000000..a9f513b0a4 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/TASK.json @@ -0,0 +1,93 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selection_nonce": "25f42878e836324a0ec903ebe7cbebf2", + "scope_key": "cdee6027333168fe48af", + "scope_status": "changed", + "actual_scope": "Find optimal scalar-polynomial pass counts and explicit stable schedules for exact-feasibility, width-13 four-qubit Clifford decoding under a discrete spectral contraction requirement.", + "scope_change_reason": "The stable width-13 decoder and sharp-denominator contributions distinguish feasibility and optimal noise; they leave the cost of convergence from the explicit seed open.", + "bottleneck_link": "Removes thousands of Gram applications from a precise oracle computation and quantifies the remaining arithmetic and acquisition gap to a priced decoder.", + "stop_rule": "Prove matching degree limits in the stated polynomial model and verify all coefficient precision, residual and intermediate-growth claims against independent spectral data.", + "outcome": "completed", + "evidence": "The package README, proof and registered verification commands describe the exact scope and controls.", + "author": "apoursh", + "ai_assistance": "Substantial OpenAI Codex assistance with mathematical derivation, verification and review.", + "open_questions": [ + { + "question": "Can the 52-pass spectrum-specific schedule be evaluated without materializing a full Gram application?", + "why_it_matters": "The algebraic pass bound leaves scalar work and input acquisition unpriced.", + "first_step": "Bind one application to a concrete compressed observation interface and track precision and movement.", + "blocked_by": "The reported schedule assumes exact operations and a Gram-operator oracle." + } + ], + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19755740", + "overlap": "Read #1163, recent #1166 handoffs, active #7111 work and recent PRs; checked relevant all-state PR searches. The local overlap cache and sparse inventory have limited coverage. Checked #7804 and the #7786 continuations for a distinct boundary.", + "upstream_refresh": { + "date_utc": "2026-11-19", + "canonical_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selected_orientation": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "selected": "The selected result is #7000. The revision-8 catalogue refers to the earlier #5599.", + "before_submission": "Fetched canonical main again and checked the current work against the live PR queue." + } +} diff --git a/research/clifford-accelerated-dyadic-decoder/VERIFY.json b/research/clifford-accelerated-dyadic-decoder/VERIFY.json new file mode 100644 index 0000000000..365f31d8f8 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/VERIFY.json @@ -0,0 +1,63 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Reconstruct scheduled dyadic multipliers, certify exact contractions and the degree obstructions" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Reconstruct scheduled dyadic multipliers, certify exact contractions and the degree obstructions under optimized Python" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-W", + "error", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 180, + "checks": "Independent spectrum, ordering controls, all prefixes and nonscalar matrix replay" + }, + { + "argv": [ + "{python}", + "-E", + "-s", + "-O", + "-W", + "error", + "-B", + "{package}/independent.py" + ], + "timeout_seconds": 180, + "checks": "Independent spectrum, ordering controls, all prefixes and nonscalar matrix replay under optimized Python" + } + ] +} diff --git a/research/clifford-accelerated-dyadic-decoder/independent.py b/research/clifford-accelerated-dyadic-decoder/independent.py new file mode 100644 index 0000000000..62aee38705 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/independent.py @@ -0,0 +1,148 @@ +"""Check the published shifts against an independently reconstructed Gram spectrum. + +Uses only the PR 7747 character projection and SCHEDULE.json. apoursh with +substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction +from hashlib import sha256 +from math import prod +from pathlib import Path +import json + +PACKAGE = Path(__file__).resolve().parent +SCALE = 2**36 + + +def check(predicate, error): + if not predicate: + raise ValueError(error) + + +def spectrum_numerators(): + raw = (PACKAGE / "sources/sp8-projection.json").read_bytes() + check(sha256(raw).hexdigest() == + "0a36754668b66480e5f968c117a4532bc3a5eaab5c9d8448f14a5d0321c2efae", + "Changed PR 7747 projection") + projection = json.loads(raw) + order = sum(projection["element_counts"]) + check(order == 47377612800 and sum(row[0]**2 for row in projection["rows"]) == order, + "Quotient degree sum") + numerators = set() + for index, (degree, *inside) in enumerate(projection["rows"]): + at_zero = (order if index == 0 else 0) - degree - sum(inside) + character = [at_zero, *inside, degree] + check(len(character) == 9, "Incomplete fixed-space sum") + weighted = sum(a*(-64)**k for k, a in enumerate(character)) + multiplicity, rem = divmod(weighted, order) + check(rem == 0 and multiplicity > 0, "Invalid width-13 multiplicity") + node, rem = divmod(SCALE * order * multiplicity, degree * 2**48) + check(rem == 0, "Chosen fixed-point denominator is insufficient") + numerators.add(node) + check(len(projection["rows"]) == 81 and len(numerators) == 52, + "Missing spectral blocks or levels") + return sorted(numerators) + + +def prefix_products(steps, nodes): + values = [1] * len(nodes) + denominator = 1 + maximum = Fraction(1) + peak_step = 0 + for j, (u, v) in enumerate(steps, 1): + divisor = SCALE * v + denominator *= divisor + values = [a*(divisor-u*x) for a, x in zip(values, nodes)] + stage_max = Fraction(max(map(abs, values)), denominator) + if stage_max > maximum: + maximum, peak_step = stage_max, j + return values, denominator, maximum, peak_step + + +def extrapolate_alternating(nodes): + # This checks the sign-alternating interpolant at zero via Newton's + # divided differences, independently of the builder's Lagrange weights. + column = [Fraction((-1)**j) for j in range(len(nodes))] + answer = column[0] + product = 1 + for j in range(1, len(nodes)): + column = [(b-a)/(y-x) + for a, b, x, y in zip(column, column[1:], nodes, nodes[j:])] + product *= -nodes[j-1] + answer += product * column[0] + return answer + + +def hadamard(vector): + return [sum((-1)**((i & j).bit_count() % 2)*x for j, x in enumerate(vector))/2 + for i in range(4)] + + +def gram_action(vector, levels): + return hadamard([x*y for x, y in zip(levels, hadamard(vector))]) + + +def data_application(steps, nodes): + # A rectangular dyadic test with four *actual* levels and a nondiagonal + # Gram matrix. Disjoint four-square expansions followed by Walsh mixing. + nodes = [nodes[j] for j in (0, 14, 31, 51)] + levels = [Fraction(w, SCALE) for w in nodes] + blocks = [] + for node in nodes: + weights = [] + j = 0 + while node: + node, digit = divmod(node, 4) + weights.extend([Fraction(2**j, 2**18)]*digit) + j += 1 + blocks.append(weights) + check([sum(t*t for t in block) for block in blocks] == levels, "Test factorization") + signal = list(map(Fraction, [1, 2, -3, 5])) + for noisy in (False, True): + observations = [[t*z + int(noisy)*(2*i+j+1) for j, t in enumerate(block)] + for i, (z, block) in enumerate(zip(hadamard(signal), blocks))] + adjoint = hadamard([sum(t*z for t, z in zip(block, vector)) + for block, vector in zip(blocks, observations)]) + decoded = hadamard([row[0]/block[0] for row, block in zip(observations, blocks)]) + canonical = hadamard([s/x for s, x in zip(hadamard(adjoint), levels)]) + initial = hadamard([a-b for a, b in zip(decoded, canonical)]) + for n, d in steps: + step = Fraction(n, d) + gram = gram_action(decoded, levels) + decoded = [a + step*(b-c) for a, b, c in zip(decoded, adjoint, gram)] + if not noisy: + check(decoded == signal, "Lost exact recovery on mixed test data") + residual = hadamard([a-b for a, b in zip(decoded, canonical)]) + expected = [a*prod(1-x*Fraction(n, d) for n, d in steps) + for a, x in zip(initial, levels)] + check(residual == expected, "Rectangular update disagrees with predicted error") + if noisy: + check(all(initial), "Test did not excite every selected level") + + +def main(): + nodes = spectrum_numerators() + saved = json.loads((PACKAGE / "SCHEDULE.json").read_text()) + dyadic = [(u, 2**b) for u, b in saved["dyadic_steps_numerator_and_fraction_bits"]] + optimal = [(u, 2**saved["norm_optimal_dyadic_fraction_bits"]) + for u in saved["norm_optimal_dyadic_numerators"]] + optimal.append(tuple(saved["norm_optimal_final_reciprocal"])) + a, d, peak, _ = prefix_products(dyadic, nodes) + check(max(map(abs, a)) << 129 < d and peak == 1 and all(a), "Dyadic contraction") + b, d, peak, _ = prefix_products(optimal, nodes) + check(max(map(abs, b)) << 58 < d and b[0] == 0 and all(b[1:]) and peak == 1, + "Norm-optimal contraction") + _, _, reverse_peak, at = prefix_products(reversed(dyadic), nodes) + check(2**138 < reverse_peak < 2**139 and at == 48, + "Reversed-order intermediate growth control") + check(2**60 < extrapolate_alternating(nodes) < 2**61, "Full-node degree witness") + check(2**52 < extrapolate_alternating(nodes[:21] + nodes[22:]) < 2**53, + "Reduced-node degree witness") + data_application(dyadic, nodes) + data_application(optimal, nodes) + print("PASS_INDEPENDENT_DECODERS levels_reconstructed=52 prefix_bound=1 " + "reverse_peak>2^138 reverse_peak_step=48 " + "mixed_rectangular_feasibility_and_noise=passed") + + +if __name__ == "__main__": + main() diff --git a/research/clifford-accelerated-dyadic-decoder/sources/sp8-projection.json b/research/clifford-accelerated-dyadic-decoder/sources/sp8-projection.json new file mode 100644 index 0000000000..406f84b469 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/sources/sp8-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-accelerated-dyadic-decoder/sources/width13-spectrum.json b/research/clifford-accelerated-dyadic-decoder/sources/width13-spectrum.json new file mode 100644 index 0000000000..039f22ba0b --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/sources/width13-spectrum.json @@ -0,0 +1,1519 @@ +{ + "source_files": 18, + "projective_order": 12128668876800, + "width": 13, + "rows": [ + { + "row": 1, + "quotient_degree": 1, + "multiplicity": 651, + "clifford_degree": 16, + "regular_dimension": 256, + "eigenvalue": [ + 470624175, + 4294967296 + ] + }, + { + "row": 2, + "quotient_degree": 35, + "multiplicity": 1518660, + "clifford_degree": 560, + "regular_dimension": 313600, + "eigenvalue": [ + 7841980575, + 1073741824 + ] + }, + { + "row": 3, + "quotient_degree": 51, + "multiplicity": 1611753, + "clifford_degree": 816, + "regular_dimension": 665856, + "eigenvalue": [ + 22846598775, + 4294967296 + ] + }, + { + "row": 4, + "quotient_degree": 85, + "multiplicity": 3148145, + "clifford_degree": 1360, + "regular_dimension": 1849600, + "eigenvalue": [ + 26774973225, + 4294967296 + ] + }, + { + "row": 5, + "quotient_degree": 119, + "multiplicity": 118482, + "clifford_degree": 1904, + "regular_dimension": 3625216, + "eigenvalue": [ + 359889075, + 2147483648 + ] + }, + { + "row": 6, + "quotient_degree": 135, + "multiplicity": 211575, + "clifford_degree": 2160, + "regular_dimension": 4665600, + "eigenvalue": [ + 1132984125, + 4294967296 + ] + }, + { + "row": 7, + "quotient_degree": 238, + "multiplicity": 5425992, + "clifford_degree": 3808, + "regular_dimension": 14500864, + "eigenvalue": [ + 4120362675, + 1073741824 + ] + }, + { + "row": 8, + "quotient_degree": 510, + "multiplicity": 620620, + "clifford_degree": 8160, + "regular_dimension": 66585600, + "eigenvalue": [ + 439864425, + 2147483648 + ] + }, + { + "row": 9, + "quotient_degree": 595, + "multiplicity": 620620, + "clifford_degree": 9520, + "regular_dimension": 90630400, + "eigenvalue": [ + 188513325, + 1073741824 + ] + }, + { + "row": 10, + "quotient_degree": 595, + "multiplicity": 2637635, + "clifford_degree": 9520, + "regular_dimension": 90630400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 11, + "quotient_degree": 918, + "multiplicity": 9570847, + "clifford_degree": 14688, + "regular_dimension": 215737344, + "eigenvalue": [ + 15074084025, + 8589934592 + ] + }, + { + "row": 12, + "quotient_degree": 1190, + "multiplicity": 4765475, + "clifford_degree": 19040, + "regular_dimension": 362521600, + "eigenvalue": [ + 5790052125, + 8589934592 + ] + }, + { + "row": 13, + "quotient_degree": 1275, + "multiplicity": 4765475, + "clifford_degree": 20400, + "regular_dimension": 416160000, + "eigenvalue": [ + 2702024325, + 4294967296 + ] + }, + { + "row": 14, + "quotient_degree": 1512, + "multiplicity": 28353468, + "clifford_degree": 24192, + "regular_dimension": 585252864, + "eigenvalue": [ + 27113003775, + 8589934592 + ] + }, + { + "row": 15, + "quotient_degree": 1785, + "multiplicity": 22608300, + "clifford_degree": 28560, + "regular_dimension": 815673600, + "eigenvalue": [ + 2289090375, + 1073741824 + ] + }, + { + "row": 16, + "quotient_degree": 1785, + "multiplicity": 3878875, + "clifford_degree": 28560, + "regular_dimension": 815673600, + "eigenvalue": [ + 1570944375, + 4294967296 + ] + }, + { + "row": 17, + "quotient_degree": 2295, + "multiplicity": 38434110, + "clifford_degree": 36720, + "regular_dimension": 1348358400, + "eigenvalue": [ + 6053372325, + 2147483648 + ] + }, + { + "row": 18, + "quotient_degree": 2856, + "multiplicity": 4592588, + "clifford_degree": 45696, + "regular_dimension": 2088124416, + "eigenvalue": [ + 2324997675, + 8589934592 + ] + }, + { + "row": 19, + "quotient_degree": 2856, + "multiplicity": 36173280, + "clifford_degree": 45696, + "regular_dimension": 2088124416, + "eigenvalue": [ + 2289090375, + 1073741824 + ] + }, + { + "row": 20, + "quotient_degree": 2975, + "multiplicity": 28260375, + "clifford_degree": 47600, + "regular_dimension": 2265760000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 21, + "quotient_degree": 2975, + "multiplicity": 42578965, + "clifford_degree": 47600, + "regular_dimension": 2265760000, + "eigenvalue": [ + 10346688495, + 4294967296 + ] + }, + { + "row": 22, + "quotient_degree": 3213, + "multiplicity": 6330324, + "clifford_degree": 51408, + "regular_dimension": 2642782464, + "eigenvalue": [ + 356080725, + 1073741824 + ] + }, + { + "row": 23, + "quotient_degree": 3213, + "multiplicity": 49512177, + "clifford_degree": 51408, + "regular_dimension": 2642782464, + "eigenvalue": [ + 11140239825, + 4294967296 + ] + }, + { + "row": 24, + "quotient_degree": 3400, + "multiplicity": 7757750, + "clifford_degree": 54400, + "regular_dimension": 2959360000, + "eigenvalue": [ + 6597966375, + 17179869184 + ] + }, + { + "row": 25, + "quotient_degree": 3570, + "multiplicity": 15825810, + "clifford_degree": 57120, + "regular_dimension": 3262694400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 26, + "quotient_degree": 3570, + "multiplicity": 7757750, + "clifford_degree": 57120, + "regular_dimension": 3262694400, + "eigenvalue": [ + 1570944375, + 4294967296 + ] + }, + { + "row": 27, + "quotient_degree": 3570, + "multiplicity": 45216600, + "clifford_degree": 57120, + "regular_dimension": 3262694400, + "eigenvalue": [ + 2289090375, + 1073741824 + ] + }, + { + "row": 28, + "quotient_degree": 3808, + "multiplicity": 42503604, + "clifford_degree": 60928, + "regular_dimension": 3712221184, + "eigenvalue": [ + 64552348575, + 34359738368 + ] + }, + { + "row": 29, + "quotient_degree": 4200, + "multiplicity": 12412400, + "clifford_degree": 67200, + "regular_dimension": 4515840000, + "eigenvalue": [ + 1068242175, + 2147483648 + ] + }, + { + "row": 30, + "quotient_degree": 4760, + "multiplicity": 10550540, + "clifford_degree": 76160, + "regular_dimension": 5800345600, + "eigenvalue": [ + 3204726525, + 8589934592 + ] + }, + { + "row": 31, + "quotient_degree": 5712, + "multiplicity": 29089346, + "clifford_degree": 91392, + "regular_dimension": 8352497664, + "eigenvalue": [ + 29452962825, + 34359738368 + ] + }, + { + "row": 32, + "quotient_degree": 5950, + "multiplicity": 56520750, + "clifford_degree": 95200, + "regular_dimension": 9063040000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 33, + "quotient_degree": 5950, + "multiplicity": 39564525, + "clifford_degree": 95200, + "regular_dimension": 9063040000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 34, + "quotient_degree": 7140, + "multiplicity": 51622285, + "clifford_degree": 114240, + "regular_dimension": 13050777600, + "eigenvalue": [ + 20907025425, + 17179869184 + ] + }, + { + "row": 35, + "quotient_degree": 8160, + "multiplicity": 67824900, + "clifford_degree": 130560, + "regular_dimension": 17045913600, + "eigenvalue": [ + 48070897875, + 34359738368 + ] + }, + { + "row": 36, + "quotient_degree": 8925, + "multiplicity": 26376350, + "clifford_degree": 142800, + "regular_dimension": 20391840000, + "eigenvalue": [ + 1068242175, + 2147483648 + ] + }, + { + "row": 37, + "quotient_degree": 8925, + "multiplicity": 62172825, + "clifford_degree": 142800, + "regular_dimension": 20391840000, + "eigenvalue": [ + 5035998825, + 4294967296 + ] + }, + { + "row": 38, + "quotient_degree": 8960, + "multiplicity": 106392000, + "clifford_degree": 143360, + "regular_dimension": 20552089600, + "eigenvalue": [ + 34336355625, + 17179869184 + ] + }, + { + "row": 39, + "quotient_degree": 9639, + "multiplicity": 42729687, + "clifford_degree": 154224, + "regular_dimension": 23785042176, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 40, + "quotient_degree": 10200, + "multiplicity": 113041500, + "clifford_degree": 163200, + "regular_dimension": 26634240000, + "eigenvalue": [ + 16023632625, + 8589934592 + ] + }, + { + "row": 41, + "quotient_degree": 11900, + "multiplicity": 52752700, + "clifford_degree": 190400, + "regular_dimension": 36252160000, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 42, + "quotient_degree": 11900, + "multiplicity": 79129050, + "clifford_degree": 190400, + "regular_dimension": 36252160000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 43, + "quotient_degree": 13056, + "multiplicity": 33761728, + "clifford_degree": 208896, + "regular_dimension": 43637538816, + "eigenvalue": [ + 7477695225, + 17179869184 + ] + }, + { + "row": 44, + "quotient_degree": 13600, + "multiplicity": 82897100, + "clifford_degree": 217600, + "regular_dimension": 47349760000, + "eigenvalue": [ + 35251991775, + 34359738368 + ] + }, + { + "row": 45, + "quotient_degree": 14280, + "multiplicity": 63303240, + "clifford_degree": 228480, + "regular_dimension": 52203110400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 46, + "quotient_degree": 14280, + "multiplicity": 137910630, + "clifford_degree": 228480, + "regular_dimension": 52203110400, + "eigenvalue": [ + 27926902575, + 17179869184 + ] + }, + { + "row": 47, + "quotient_degree": 14688, + "multiplicity": 48532484, + "clifford_degree": 235008, + "regular_dimension": 55228760064, + "eigenvalue": [ + 19109665575, + 34359738368 + ] + }, + { + "row": 48, + "quotient_degree": 16065, + "multiplicity": 55390335, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 2492565075, + 4294967296 + ] + }, + { + "row": 49, + "quotient_degree": 16065, + "multiplicity": 65940875, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 2967339375, + 4294967296 + ] + }, + { + "row": 50, + "quotient_degree": 16065, + "multiplicity": 87041955, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 3916887975, + 4294967296 + ] + }, + { + "row": 51, + "quotient_degree": 16065, + "multiplicity": 169562250, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 3815150625, + 2147483648 + ] + }, + { + "row": 52, + "quotient_degree": 16065, + "multiplicity": 118693575, + "clifford_degree": 257040, + "regular_dimension": 66069561600, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 53, + "quotient_degree": 17850, + "multiplicity": 52752700, + "clifford_degree": 285600, + "regular_dimension": 81567360000, + "eigenvalue": [ + 1068242175, + 2147483648 + ] + }, + { + "row": 54, + "quotient_degree": 17850, + "multiplicity": 124345650, + "clifford_degree": 285600, + "regular_dimension": 81567360000, + "eigenvalue": [ + 5035998825, + 4294967296 + ] + }, + { + "row": 55, + "quotient_degree": 18360, + "multiplicity": 93447640, + "clifford_degree": 293760, + "regular_dimension": 86294937600, + "eigenvalue": [ + 3679500825, + 4294967296 + ] + }, + { + "row": 56, + "quotient_degree": 19040, + "multiplicity": 73853780, + "clifford_degree": 304640, + "regular_dimension": 92805529600, + "eigenvalue": [ + 22433085675, + 34359738368 + ] + }, + { + "row": 57, + "quotient_degree": 23800, + "multiplicity": 195938600, + "clifford_degree": 380800, + "regular_dimension": 145008640000, + "eigenvalue": [ + 5951634975, + 4294967296 + ] + }, + { + "row": 58, + "quotient_degree": 23800, + "multiplicity": 226083000, + "clifford_degree": 380800, + "regular_dimension": 145008640000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 59, + "quotient_degree": 26775, + "multiplicity": 254343375, + "clifford_degree": 428400, + "regular_dimension": 183526560000, + "eigenvalue": [ + 6867271125, + 4294967296 + ] + }, + { + "row": 60, + "quotient_degree": 26775, + "multiplicity": 118693575, + "clifford_degree": 428400, + "regular_dimension": 183526560000, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 61, + "quotient_degree": 28560, + "multiplicity": 158258100, + "clifford_degree": 456960, + "regular_dimension": 208812441600, + "eigenvalue": [ + 16023632625, + 17179869184 + ] + }, + { + "row": 62, + "quotient_degree": 28917, + "multiplicity": 250273881, + "clifford_degree": 462672, + "regular_dimension": 214065379584, + "eigenvalue": [ + 6256847025, + 4294967296 + ] + }, + { + "row": 63, + "quotient_degree": 30464, + "multiplicity": 231508992, + "clifford_degree": 487424, + "regular_dimension": 237582155776, + "eigenvalue": [ + 1373454225, + 1073741824 + ] + }, + { + "row": 64, + "quotient_degree": 32130, + "multiplicity": 131881750, + "clifford_degree": 514080, + "regular_dimension": 264278246400, + "eigenvalue": [ + 2967339375, + 4294967296 + ] + }, + { + "row": 65, + "quotient_degree": 32130, + "multiplicity": 166171005, + "clifford_degree": 514080, + "regular_dimension": 264278246400, + "eigenvalue": [ + 7477695225, + 8589934592 + ] + }, + { + "row": 66, + "quotient_degree": 32130, + "multiplicity": 237387150, + "clifford_degree": 514080, + "regular_dimension": 264278246400, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 67, + "quotient_degree": 34425, + "multiplicity": 118693575, + "clifford_degree": 550800, + "regular_dimension": 303380640000, + "eigenvalue": [ + 2492565075, + 4294967296 + ] + }, + { + "row": 68, + "quotient_degree": 34425, + "multiplicity": 254343375, + "clifford_degree": 550800, + "regular_dimension": 303380640000, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 69, + "quotient_degree": 34560, + "multiplicity": 158878720, + "clifford_degree": 552960, + "regular_dimension": 305764761600, + "eigenvalue": [ + 830855025, + 1073741824 + ] + }, + { + "row": 70, + "quotient_degree": 38080, + "multiplicity": 168808640, + "clifford_degree": 609280, + "regular_dimension": 371222118400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 71, + "quotient_degree": 38556, + "multiplicity": 170918748, + "clifford_degree": 616896, + "regular_dimension": 380560674816, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 72, + "quotient_degree": 42525, + "multiplicity": 314188875, + "clifford_degree": 680400, + "regular_dimension": 462944160000, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 73, + "quotient_degree": 42525, + "multiplicity": 314188875, + "clifford_degree": 680400, + "regular_dimension": 462944160000, + "eigenvalue": [ + 5341210875, + 4294967296 + ] + }, + { + "row": 74, + "quotient_degree": 43520, + "multiplicity": 265270720, + "clifford_degree": 696320, + "regular_dimension": 484861542400, + "eigenvalue": [ + 35251991775, + 34359738368 + ] + }, + { + "row": 75, + "quotient_degree": 47600, + "multiplicity": 316516200, + "clifford_degree": 761600, + "regular_dimension": 580034560000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 76, + "quotient_degree": 48195, + "multiplicity": 213648435, + "clifford_degree": 771120, + "regular_dimension": 594626054400, + "eigenvalue": [ + 3204726525, + 4294967296 + ] + }, + { + "row": 77, + "quotient_degree": 51408, + "multiplicity": 322846524, + "clifford_degree": 822528, + "regular_dimension": 676552310784, + "eigenvalue": [ + 18160116975, + 17179869184 + ] + }, + { + "row": 78, + "quotient_degree": 53550, + "multiplicity": 356080725, + "clifford_degree": 856800, + "regular_dimension": 734106240000, + "eigenvalue": [ + 9614179575, + 8589934592 + ] + }, + { + "row": 79, + "quotient_degree": 57120, + "multiplicity": 316516200, + "clifford_degree": 913920, + "regular_dimension": 835249766400, + "eigenvalue": [ + 16023632625, + 17179869184 + ] + }, + { + "row": 80, + "quotient_degree": 65536, + "multiplicity": 381308928, + "clifford_degree": 1048576, + "regular_dimension": 1099511627776, + "eigenvalue": [ + 67299257025, + 68719476736 + ] + }, + { + "row": 81, + "quotient_degree": 68850, + "multiplicity": 356080725, + "clifford_degree": 1101600, + "regular_dimension": 1213522560000, + "eigenvalue": [ + 7477695225, + 8589934592 + ] + } + ], + "distinct_levels": [ + { + "eigenvalue": [ + 470624175, + 4294967296 + ], + "rows": [ + 1 + ], + "eigenspace_dimension": 256 + }, + { + "eigenvalue": [ + 359889075, + 2147483648 + ], + "rows": [ + 5 + ], + "eigenspace_dimension": 3625216 + }, + { + "eigenvalue": [ + 188513325, + 1073741824 + ], + "rows": [ + 9 + ], + "eigenspace_dimension": 90630400 + }, + { + "eigenvalue": [ + 439864425, + 2147483648 + ], + "rows": [ + 8 + ], + "eigenspace_dimension": 66585600 + }, + { + "eigenvalue": [ + 1132984125, + 4294967296 + ], + "rows": [ + 6 + ], + "eigenspace_dimension": 4665600 + }, + { + "eigenvalue": [ + 2324997675, + 8589934592 + ], + "rows": [ + 18 + ], + "eigenspace_dimension": 2088124416 + }, + { + "eigenvalue": [ + 356080725, + 1073741824 + ], + "rows": [ + 22 + ], + "eigenspace_dimension": 2642782464 + }, + { + "eigenvalue": [ + 1570944375, + 4294967296 + ], + "rows": [ + 16, + 26 + ], + "eigenspace_dimension": 4078368000 + }, + { + "eigenvalue": [ + 3204726525, + 8589934592 + ], + "rows": [ + 30 + ], + "eigenspace_dimension": 5800345600 + }, + { + "eigenvalue": [ + 6597966375, + 17179869184 + ], + "rows": [ + 24 + ], + "eigenspace_dimension": 2959360000 + }, + { + "eigenvalue": [ + 7477695225, + 17179869184 + ], + "rows": [ + 43 + ], + "eigenspace_dimension": 43637538816 + }, + { + "eigenvalue": [ + 1068242175, + 2147483648 + ], + "rows": [ + 29, + 36, + 53 + ], + "eigenspace_dimension": 106475040000 + }, + { + "eigenvalue": [ + 19109665575, + 34359738368 + ], + "rows": [ + 47 + ], + "eigenspace_dimension": 55228760064 + }, + { + "eigenvalue": [ + 2492565075, + 4294967296 + ], + "rows": [ + 48, + 67 + ], + "eigenspace_dimension": 369450201600 + }, + { + "eigenvalue": [ + 2702024325, + 4294967296 + ], + "rows": [ + 13 + ], + "eigenspace_dimension": 416160000 + }, + { + "eigenvalue": [ + 22433085675, + 34359738368 + ], + "rows": [ + 56 + ], + "eigenspace_dimension": 92805529600 + }, + { + "eigenvalue": [ + 5790052125, + 8589934592 + ], + "rows": [ + 12 + ], + "eigenspace_dimension": 362521600 + }, + { + "eigenvalue": [ + 2967339375, + 4294967296 + ], + "rows": [ + 49, + 64 + ], + "eigenspace_dimension": 330347808000 + }, + { + "eigenvalue": [ + 3204726525, + 4294967296 + ], + "rows": [ + 10, + 25, + 39, + 41, + 45, + 60, + 70, + 71, + 76 + ], + "eigenspace_dimension": 1645529044992 + }, + { + "eigenvalue": [ + 830855025, + 1073741824 + ], + "rows": [ + 69 + ], + "eigenspace_dimension": 305764761600 + }, + { + "eigenvalue": [ + 3679500825, + 4294967296 + ], + "rows": [ + 55 + ], + "eigenspace_dimension": 86294937600 + }, + { + "eigenvalue": [ + 29452962825, + 34359738368 + ], + "rows": [ + 31 + ], + "eigenspace_dimension": 8352497664 + }, + { + "eigenvalue": [ + 7477695225, + 8589934592 + ], + "rows": [ + 65, + 81 + ], + "eigenspace_dimension": 1477800806400 + }, + { + "eigenvalue": [ + 3916887975, + 4294967296 + ], + "rows": [ + 50 + ], + "eigenspace_dimension": 66069561600 + }, + { + "eigenvalue": [ + 16023632625, + 17179869184 + ], + "rows": [ + 61, + 79 + ], + "eigenspace_dimension": 1044062208000 + }, + { + "eigenvalue": [ + 67299257025, + 68719476736 + ], + "rows": [ + 80 + ], + "eigenspace_dimension": 1099511627776 + }, + { + "eigenvalue": [ + 35251991775, + 34359738368 + ], + "rows": [ + 44, + 74 + ], + "eigenspace_dimension": 532211302400 + }, + { + "eigenvalue": [ + 18160116975, + 17179869184 + ], + "rows": [ + 77 + ], + "eigenspace_dimension": 676552310784 + }, + { + "eigenvalue": [ + 9614179575, + 8589934592 + ], + "rows": [ + 33, + 42, + 75, + 78 + ], + "eigenspace_dimension": 1359456000000 + }, + { + "eigenvalue": [ + 5035998825, + 4294967296 + ], + "rows": [ + 37, + 54 + ], + "eigenspace_dimension": 101959200000 + }, + { + "eigenvalue": [ + 20907025425, + 17179869184 + ], + "rows": [ + 34 + ], + "eigenspace_dimension": 13050777600 + }, + { + "eigenvalue": [ + 5341210875, + 4294967296 + ], + "rows": [ + 52, + 66, + 68, + 72, + 73 + ], + "eigenspace_dimension": 1559616768000 + }, + { + "eigenvalue": [ + 1373454225, + 1073741824 + ], + "rows": [ + 63 + ], + "eigenspace_dimension": 237582155776 + }, + { + "eigenvalue": [ + 5951634975, + 4294967296 + ], + "rows": [ + 57 + ], + "eigenspace_dimension": 145008640000 + }, + { + "eigenvalue": [ + 48070897875, + 34359738368 + ], + "rows": [ + 35 + ], + "eigenspace_dimension": 17045913600 + }, + { + "eigenvalue": [ + 6256847025, + 4294967296 + ], + "rows": [ + 62 + ], + "eigenspace_dimension": 214065379584 + }, + { + "eigenvalue": [ + 6867271125, + 4294967296 + ], + "rows": [ + 20, + 32, + 58, + 59 + ], + "eigenspace_dimension": 339864000000 + }, + { + "eigenvalue": [ + 27926902575, + 17179869184 + ], + "rows": [ + 46 + ], + "eigenspace_dimension": 52203110400 + }, + { + "eigenvalue": [ + 15074084025, + 8589934592 + ], + "rows": [ + 11 + ], + "eigenspace_dimension": 215737344 + }, + { + "eigenvalue": [ + 3815150625, + 2147483648 + ], + "rows": [ + 51 + ], + "eigenspace_dimension": 66069561600 + }, + { + "eigenvalue": [ + 16023632625, + 8589934592 + ], + "rows": [ + 40 + ], + "eigenspace_dimension": 26634240000 + }, + { + "eigenvalue": [ + 64552348575, + 34359738368 + ], + "rows": [ + 28 + ], + "eigenspace_dimension": 3712221184 + }, + { + "eigenvalue": [ + 34336355625, + 17179869184 + ], + "rows": [ + 38 + ], + "eigenspace_dimension": 20552089600 + }, + { + "eigenvalue": [ + 2289090375, + 1073741824 + ], + "rows": [ + 15, + 19, + 27 + ], + "eigenspace_dimension": 6166492416 + }, + { + "eigenvalue": [ + 10346688495, + 4294967296 + ], + "rows": [ + 21 + ], + "eigenspace_dimension": 2265760000 + }, + { + "eigenvalue": [ + 11140239825, + 4294967296 + ], + "rows": [ + 23 + ], + "eigenspace_dimension": 2642782464 + }, + { + "eigenvalue": [ + 6053372325, + 2147483648 + ], + "rows": [ + 17 + ], + "eigenspace_dimension": 1348358400 + }, + { + "eigenvalue": [ + 27113003775, + 8589934592 + ], + "rows": [ + 14 + ], + "eigenspace_dimension": 585252864 + }, + { + "eigenvalue": [ + 4120362675, + 1073741824 + ], + "rows": [ + 7 + ], + "eigenspace_dimension": 14500864 + }, + { + "eigenvalue": [ + 22846598775, + 4294967296 + ], + "rows": [ + 3 + ], + "eigenspace_dimension": 665856 + }, + { + "eigenvalue": [ + 26774973225, + 4294967296 + ], + "rows": [ + 4 + ], + "eigenspace_dimension": 1849600 + }, + { + "eigenvalue": [ + 7841980575, + 1073741824 + ], + "rows": [ + 2 + ], + "eigenspace_dimension": 313600 + } + ], + "minimum": [ + 470624175, + 4294967296 + ], + "maximum": [ + 7841980575, + 1073741824 + ], + "minimum_dimension": 256, + "maximum_dimension": 313600, + "gram_condition": [ + 101244, + 1519 + ], + "inverse_squared_norm": [ + 4294967296, + 470624175 + ], + "second_moment": [ + 930080652310818734947227759375, + 72057594037927936 + ], + "one_qubit_calibration": { + "projective_elements": 24, + "closure_products": 576, + "quotient_character_counts": [ + [ + -64, + 12 + ], + [ + 1, + 8 + ], + [ + 4096, + 4 + ] + ], + "multiplicities": [ + 651, + 715, + 1365 + ], + "eigenvalues": [ + [ + 1953, + 2048 + ], + [ + 2145, + 2048 + ], + [ + 4095, + 4096 + ] + ], + "eigenspace_dimensions": [ + 4, + 4, + 16 + ], + "gram_second_moment": [ + 25184259, + 1048576 + ], + "literal_cubic_annihilator": true, + "normalization_controls": 3 + } +} diff --git a/research/clifford-accelerated-dyadic-decoder/verify.py b/research/clifford-accelerated-dyadic-decoder/verify.py new file mode 100644 index 0000000000..5cd9830f96 --- /dev/null +++ b/research/clifford-accelerated-dyadic-decoder/verify.py @@ -0,0 +1,186 @@ +"""Generate and check both width-13 schedules using exact rational arithmetic. + +apoursh with substantial OpenAI Codex assistance. Apache-2.0. +""" +from fractions import Fraction +from hashlib import sha256 +from math import gcd, lcm, prod +from pathlib import Path +import argparse +import json + +ROOT = Path(__file__).resolve().parent + + +def require(condition, error): + if not condition: + raise ValueError(error) + + +def levels(): + raw = (ROOT / "sources/width13-spectrum.json").read_bytes() + require(sha256(raw).hexdigest() == + "d032d5e63820f4ffe246d21adcd8d272f04dfd635a6fc519c4a81a366ca41d49", + "Changed PR 7772 spectrum") + source = json.loads(raw) + order = source["projective_order"] + rows = source["rows"] + values = set() + for row in rows: + degree = 16 * row["quotient_degree"] + value = Fraction(*row["eigenvalue"]) + require(row["clifford_degree"] == degree and row["regular_dimension"] == degree**2, + "Incorrect Clifford multiplicity") + require(value == Fraction(order * row["multiplicity"], 16**13 * degree), + "Incorrect normalized eigenvalue") + values.add(value) + require(sum(row["regular_dimension"] for row in rows) == order == 12128668876800, + "Incomplete regular representation") + require(source["width"] == 13 and len(rows) == 81 and len(values) == 52, + "Wrong width or number of levels") + return sorted(values) + + +def ceil_log2(value): + exponent = value.numerator.bit_length() - value.denominator.bit_length() + return exponent + int(value > Fraction(2)**exponent) + + +def dyadic_factors(values): + schedule = [] + for x in reversed(values): + sensitivity = x * prod(abs(1 - x/y) for y in values if y != x) + separation = max(64*y/abs(1 - y/x) for y in values if y != x) + bits = max(0, ceil_log2((1 << 128) * sensitivity), ceil_log2(separation)) + schedule.append([round((1 << bits)/x), bits]) + return schedule + + +def evaluate(coefficients, x): + result = 0 + for c in coefficients: + result = result*x + c + return result + + +def alternating_polynomial(nodes): + """Power-basis integer polynomial in t=2^36 x with the prescribed root set.""" + bottom, *positive = nodes + # The common product and synthetic division give each Lagrange basis. + product = [1] + for z in positive: + product = [a-z*b for a, b in zip(product+[0], [0]+product)] + coefficients = [Fraction(0)] * len(positive) + for j, z in enumerate(positive): + slope = prod(z-w for w in positive if w != z) + weight = Fraction((-1)**j * bottom, (bottom-z) * slope) + quotient = [1] + for c in product[1:-1]: + quotient.append(c + z * quotient[-1]) + require(product[-1] + z*quotient[-1] == 0, "Synthetic division remainder") + coefficients = [a + weight*b for a, b in zip(coefficients, quotient)] + common = lcm(*(c.denominator for c in coefficients)) + integers = [int(c*common) for c in coefficients] + divisor = gcd(*integers) + return [a//divisor for a in integers] + + +def optimal_factors(values): + scale = lcm(*(x.denominator for x in values)) + nodes = [int(scale*x) for x in values] + coefficients = alternating_polynomial(nodes) + require(scale == 2**36 and len(coefficients) == 51 and coefficients[0] != 0, + "Expected 50 separating roots") + bits = 192 + unit = scale << bits + # At u>0 the sign of u^50 R(unit/u) locates the reciprocal root + # on the 2^-192 grid without evaluating an algebraic number. + reciprocal = [c * unit**j for j, c in enumerate(reversed(coefficients))] + numerators = [] + for low, high in zip(nodes[1:], nodes[2:]): + at_high = evaluate(coefficients, high) + require(at_high * evaluate(coefficients, low) < 0, "Missing alternating roots") + left, right = unit//high, -(-unit//low) + while right-left > 1: + middle = (left+right)//2 + # Every tested midpoint lies strictly inside (unit/high, unit/low). + value = evaluate(reciprocal, middle) + if value == 0: + left = middle + break + if (value > 0) == (at_high > 0): + left = middle + else: + right = middle + numerators.append(left) + return list(reversed(numerators)) + + +def representation(values): + return { + "width": 13, + "target_contraction_bits": 128, + "dyadic_steps_numerator_and_fraction_bits": dyadic_factors(values), + "norm_optimal_dyadic_fraction_bits": 192, + "norm_optimal_dyadic_numerators": optimal_factors(values), + "norm_optimal_final_reciprocal": [values[0].denominator, values[0].numerator], + } + + +def residuals(steps, values): + return [prod(1-alpha*x for alpha in steps) for x in values] + + +def extrapolation_weight_sum(nodes): + return sum(prod(abs(y/(y-x)) for y in nodes if y != x) for x in nodes) + + +def audit(receipt, values): + first = receipt["dyadic_steps_numerator_and_fraction_bits"] + steps = [Fraction(n, 1 << b) for n, b in first] + require(len(steps) == 52 and steps == sorted(steps) and steps[0] > 0, + "Unstable ordering") + peak = max(map(abs, residuals(steps, values))) + require(Fraction(1, 2**130) < peak < Fraction(1, 2**129), "Dyadic residual") + fractions = [b for _, b in first] + require((min(fractions), max(fractions), sum(fractions)) == (69, 266, 5676), + "Dyadic scalar precision") + used = sum(a.denominator.bit_length()-1 for a in steps) + require(used == 5627, "Reduced denominator budget") + optimal = [Fraction(n, 1 << 192) for n in receipt["norm_optimal_dyadic_numerators"]] + optimal.append(Fraction(*receipt["norm_optimal_final_reciprocal"])) + require(len(optimal) == 51 and optimal == sorted(optimal) and optimal[0] > 0, + "Unstable optimum ordering") + remaining = residuals(optimal, values) + peak = max(map(abs, remaining)) + require(remaining[0] == 0 and Fraction(1, 2**59) < peak < Fraction(1, 2**58), + "Norm-optimal residual") + require(1/values[0] - 1/values[1] > 3 and 1/values[0] < 10, + "Insufficient gap or wrong norm floor") + full = extrapolation_weight_sum(values) + most = extrapolation_weight_sum(values[:21] + values[22:]) + require(2**60 < full < 2**61 and 2**52 < most < 2**53, + "Polynomial degree lower certificates") + print("PASS_ACCELERATED_DECODERS dyadic_steps=52 dyadic_residual<2^-129 " + "dyadic_reduced_fraction_bits_sum=5627 optimal_steps=51 " + "optimal_residual<2^-58 optimal_odd_denominator=470624175 " + "degree_51_floor>2^-61 degree_50_floor>2^-53") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--emit-schedule", action="store_true", + help="write the reproducible schedule to stdout") + args = parser.parse_args() + values = levels() + receipt = representation(values) + if args.emit_schedule: + print(json.dumps(receipt, indent=2)) + else: + require(json.loads((ROOT / "SCHEDULE.json").read_text()) == receipt, + "Committed schedule differs from reconstruction") + audit(receipt, values) + + +if __name__ == "__main__": + main()