From 7f08a74037788311cc6b7da27297b25f1b188e45 Mon Sep 17 00:00:00 2001 From: apoursh <8867770+apoursh@users.noreply.github.com> Date: Thu, 19 Nov 2026 10:45:17 -0500 Subject: [PATCH] Prove the sharp dyadic four-qubit Clifford tensor width is thirteen --- research/clifford-bell-fibres/PROOF.md | 264 ++++++++++++++++ research/clifford-bell-fibres/README.md | 34 +++ research/clifford-bell-fibres/SOURCES.json | 50 +++ research/clifford-bell-fibres/TASK.json | 101 +++++++ research/clifford-bell-fibres/VERIFY.json | 59 ++++ .../clifford-bell-fibres/independent_check.py | 284 ++++++++++++++++++ research/clifford-bell-fibres/verify.py | 220 ++++++++++++++ 7 files changed, 1012 insertions(+) create mode 100644 research/clifford-bell-fibres/PROOF.md create mode 100644 research/clifford-bell-fibres/README.md create mode 100644 research/clifford-bell-fibres/SOURCES.json create mode 100644 research/clifford-bell-fibres/TASK.json create mode 100644 research/clifford-bell-fibres/VERIFY.json create mode 100644 research/clifford-bell-fibres/independent_check.py create mode 100644 research/clifford-bell-fibres/verify.py diff --git a/research/clifford-bell-fibres/PROOF.md b/research/clifford-bell-fibres/PROOF.md new file mode 100644 index 0000000000..ec75379650 --- /dev/null +++ b/research/clifford-bell-fibres/PROOF.md @@ -0,0 +1,264 @@ +# A Gaussian-dyadic left inverse at the sharp four-qubit width + +Let `R = Z[i,1/2]`, `d = 16`, and fix one Gaussian-dyadic unitary `U` in +each four-qubit Clifford coset modulo scalar powers of `i`. Let `A_f` have +columns `(vec(U)/4)^(tensor f)`. Vectorizing the tensor-power matrices in +one step instead merely permutes the coordinates. + +**Theorem.** There is an explicit matrix over `R` with `B_f A_f = I` at +every integer `f >= 13`. Together with the reported complex rank failure +below width 13 in [Ali Romman's #7766](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/PROOF.md), +this determines the least Gaussian-dyadic width as 13. The construction +of the upper bound is independent of that spectral calculation. + +## 1. Six Bell pairs and one matrix + +Write `V = F_2^4 ⊕ F_2^4` and use unphased real Weyl matrices +`W_t = X^x Z^z` for `t=(x,z)`. The commutation sign is the symplectic +pairing ` = x·z' + z·x'`, and `W_t^T = (-1)^q(t) W_t` with +`q(t)=x·z`. The 256 vectors `vec(W_t)/4` form an orthonormal basis of +the two-register space. Conjugation by a Clifford gives + +```text +U W_t U* = gamma_U(t) W_(St), S in G = Sp(V). +``` + +All phases here and below are units of `R`. A scalar of modulus one in +`R` is a power of `i`, by reducing a sum of two squares equal to a power +of four modulo four and dividing through by four repeatedly. The usual +Clifford action surjects onto `G`. A Hermitian Pauli lift `P` of each +nonzero `p` gives a dyadic unitary `(1+i)(I+iP)/2` inducing the +symplectic transvection at `p`, and these generate the symplectic group. +Its projective kernel consists of the Weyl matrices. Indeed, a Clifford +fixing every label has conjugation signs in `{+1,-1}` by squaring +`W_t`. These signs form a character of `V`, hence have the form +`(-1)^`. After removing `W_p` the unitary commutes with every Weyl +matrix, which forces it to be scalar. Thus each fibre of the map to +`S` consists of 256 representatives proportional to `W_p U_S`. + +On a Bell pair the action of `U ⊗ U` reads + +```text +U W_t U^T = theta_U(t) W_(L_S t), L_S t = St + b_S . +``` + +In fact `U bar(U)^(-1) = U U^T` is a Pauli up to phase, since entrywise +conjugation preserves the symplectic action on the real Weyls. Left +multiplication of `U` by any Pauli preserves all labels in this formula. +The affine maps compose, as follows directly by applying the two-register +action twice. Transposition also gives `q(L_S t)=q(t)`. + +For an ordered six-tuple `t=(t_1,...,t_6)` put `w=sum_i t_i` over the +binary field. If its output is `t'=L_S t` componentwise, then +`w'=sum_i t'_i = Sw`, since six copies cancel the affine offset. Under +the Bell basis change on six pairs, the block of `U^(tensor 13)` between +these tuples is `beta_U(t) U`, where `beta_U(t)=product_i theta_U(t_i)`. +Every other output block for this input is zero. Left multiply this +observed block by `W_(w')` and right multiply by `W_w^(-1)`. The block +becomes + +```text +sigma_S(t) U, sigma_S(t) = beta_U(t) / gamma_U(w). +``` + +This phase depends only on `S`. Replacing `U` by `W_p U` multiplies each +Bell phase by `(-1)^` since `W_p^T=W_p^(-1)`, hence multiplies the product by +`(-1)^`. The same sign multiplies `gamma_U(w)`. A scalar lift +`zU` contributes `z^12=1` to the product and leaves conjugation unchanged. +Composition in the two matrix actions gives +`sigma_(S_1 S_2)(t) = sigma_(S_1)(L_(S_2)t) sigma_(S_2)(t)`. + +All these operations are fixed `R`-linear maps on the observations. +Concretely, first multiply by `4^13` to undo the column normalization, +then unvectorize, regroup six pairs, and take the stated input and output +Bell matrix elements. This reasoning by columns therefore also applies +to an arbitrary mixture with coefficients `c_U`. + +## 2. Which sums the orbit supplies + +Write `Z_j, X_j` for the corresponding binary labels, and let +`L = span(Z_1,...,Z_4)`. Use the ordered seed + +```text +T = (0, Z_1, Z_2, Z_3, Z_4, X_4). +``` + +A symplectic map stabilizing this tuple in the Bell action has `b_S=0`, +fixes `L` pointwise and fixes `X_4`. Fixing `L` pointwise forces a shear +`(x,z) -> (x,z+Bx)` with `B` symmetric. Fixing `X_4` means its fourth +row and column vanish. Preserving `q`, now with zero offset, forces +zero diagonal. Conversely the three ordinary real controlled-Z gates +on qubit pairs 12, 13 and 23 generate all eight such shears. Their lifts +fix each seed Weyl by ordinary conjugation and have `UU^T=I`. +They also fix the product of the seed Weyls, hence `gamma_U(w)=1`. +Thus the stabilizer `C` has order eight and `sigma_c(T)=1` throughout. + +Identify the orbit of `T` with `G/C`. For each tuple `i` there, fix any +transporter `g_i` from the seed, and put `j_i = sigma_(g_i)(T)`. The +cocycle and its trivial value on `C` make this phase independent of the +transporter. For `S i=j` we have `sigma_S(i)=j_j/j_i`. Define the +unknown fibre matrix `M_S=sum_(U over S) c_U U`. Multiplying each +corrected observation block by `j_i/j_j` therefore exposes the sum + +```text +sum_(S in g_j C g_i^(-1)) M_S . +``` + +An explicit transporter can always be chosen by finite enumeration. +For any subgroup `H` of power-of-two order write `e_H = sum_(h in H) h/|H|` +in the group algebra `R[G]`. The coefficient vectors of the available +coset sums are precisely the coefficient vectors of the elements +`8 g_j e_C g_i^(-1)`. Arbitrary left or right translates yield the +same set, since group elements can be replaced by coset representatives. +Consequently we can recover every `M_S` linearly over `R` once + +```text +R[G] e_C R[G] = R[G]. +``` + +## 3. A dyadic identity for the stabilizer average + +Take the full abelian shear group `A = Sym_4(F_2)` fixing `L` pointwise, +including its diagonal entries. Regard a shear parameter `B` as a +symmetric matrix on a chosen basis of `L`. For any vectors `u,v` of +`L`, write `B_uv = uv^T + vu^T`. Each character of `A` is determined +by a binary quadratic form `Q` on `L` as follows: + +```text +chi_Q(uu^T) = (-1)^Q(u), chi_Q(B_uv) = (-1)^lambda(u,v), +lambda(u,v) = Q(u+v)+Q(u)+Q(v). +``` + +Indeed, the four diagonal coefficients and six off-diagonal +coefficients of a linear functional on symmetric matrices freely +specify the four linear and six cross coefficients of `Q`. For each +of these 1,024 characters set +`e_Q = 2^-10 sum_(B in A) chi_Q(B) B`, using group elements in this +sum. Character orthogonality gives pairwise orthogonal idempotents with +`sum_Q e_Q=1`. A basis change `g` of `L`, acting contragrediently on +the complementary dual, sends `B` to `g B g^T`, so acts on the +characters by the natural change of variables. + +For any isotropic three-plane `W <= V` the conjugate `C_W` of `C` +consists of the eight products of its three pair shears. In basis-free +terms the generators for basis pairs `u,v` send +`s -> s + v + u`. This is the seed description above for +`W=span(Z_1,Z_2,Z_3)`, transported by a symplectic change of basis. +The stated map for each pair and all their products depend only on +`W`. Such basis changes exist by extension of an isotropic basis to +a symplectic basis. In particular, each `e_(C_W)` belongs to the +two-sided ideal generated by `e_C`. + +If the alternating polar form `lambda` of `Q` is degenerate, choose a +three-plane `W <= L` isotropic for `lambda`. Its existence follows +from the rank being zero or two. In rank two, extend the two-dimensional +radical by any vector outside it. Then `C_W <= A` and `chi_Q` is one +on its three generators. Hence `e_Q e_(C_W) e_Q=e_Q`. + +Now let `lambda` be nondegenerate. There exists a nonzero `r in L` +with `Q(r)=0`: on a two-dimensional `lambda`-isotropic plane `Q` +is linear, so has a nonzero zero. Set `H=r^perp` for this polar form, +take a basis `z_1=r,z_2,z_3` of `H` and extend it by `z_4` to `L`. +Then `lambda(z_4,r)=1`. Put `P=span(r,z_2)`. In the complementary +dual Lagrangian take `x_4` pairing one with `z_4` and zero with `H` +in the original symplectic form on `V`. Choose the mixed isotropic plane + +```text +W = span(r,z_2,x_4). +``` + +Its group `C_W` consists of the eight products of `B_(r,z_2)` and the +four basis changes `T_p` for `p in P` sending `z_4 -> z_4+p` and fixing +`H` pointwise, with contragredient action on the dual. This follows +from the three pair-shear formulas. Every element normalizes `A` and +`chi_Q(B_(r,z_2))=1`. + +For each nonzero `p in P`, the character moves under `T_p`. If `p=r`, +then `Q(z_4+r)=Q(z_4)+1`. If `p` is outside the span of `r`, then +`p` is outside the radical of `lambda|H`, which is the line through +`r`. Pick `y in H` with `lambda(p,y)=1`. The transformation changes +`lambda(z_4,y)`, hence changes `Q`. Thus only the two elements of +`C_W` with `p=0` stabilize the character. For each of those, +`e_Q c e_Q=e_Q`; for every other `c`, orthogonality of `e_Q` and +`c e_Q c^(-1)` gives zero. Consequently + +```text +e_Q e_(C_W) e_Q = (2/8) e_Q = e_Q/4 . +``` + +This constructs the identity in the ideal. For each `Q` choose a plane +and a transporter `g_Q` as above. With coefficient `d_Q=1` in the +degenerate case and `d_Q=4` in the nondegenerate case, + +```text +1 = sum_Q d_Q e_Q g_Q e_C g_Q^(-1) e_Q . +``` + +Expanding the character idempotents expresses this formula as a +dyadic linear combination of the available translates. Multiplying +by each group element on the left gives all single-fibre indicators. +There is no division by the order of the symplectic group. + +## 4. Decode the Pauli fibre and pad + +For each fixed projective representative `U` over `S`, return +`Tr(U* M_S)/16`. Any other representative over `S` differs by a +nonidentity Pauli on the left up to scalar, and has zero trace pairing +with `U`. The target pairing is 16, so this recovers exactly `c_U`. +It uses coefficients in `R`, even for arbitrary fixed scalar lifts. +Together the steps specify a linear left inverse on the entire +observation space. At larger widths, tensor each row with `f-13` +copies of its target's single-copy functional `(vec(U)/4)^*`. This +functional is one on the target column. All other columns are already +annihilated by the first thirteen factors. Applying any ring homomorphism +from R to a residue field preserves the identity B_f A_f = I. In +particular, the columns remain independent modulo every odd Gaussian +prime for f >= 13, including characteristics dividing the group order. + +## 5. Stability on the normalized observations + +The single functional which extracts one corrected coset block and traces +it against `U*/16` has Euclidean row norm `4^13/4 = 4^12`. The Bell +input and output vectors have unit norm, the Weyl corrections are unitary, +and `||U/16||_F=1/4`. Each `e_Q` has coefficient absolute sum one. +The expansion in Section 3 therefore costs at most `sum_Q d_Q/8 <= 512` +in absolute coefficients of coset sums. This bounds the norm of each row +of `B_13` by `2^33`. Tensoring with the unit-norm padding preserves that +bound for every `f>=13`. With `N=12,128,668,876,800` rows we obtain +`||B_f||_2 <= sqrt(N) 2^33 < 2^55`. + +Assume the published uniform spectral enclosure of Ali Romman's +[#7772, exact source](https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/PROOF.md). +For `A=A_f` and `K=A* A` it gives eigenvalues in +`[470624175/2^32, 7841980575/2^30]`. Start at `D_0=B_f` and use the +exact dyadic iteration from [#7798, Section 4](https://github.com/apoursh/integer-mult-bounds/blob/0ae10f215780296ca50142fd36fdf904b8c1b146/research/clifford-width17/PROOF.md#4-exact-dyadic-stabilization): + +```text +D_(j+1) = (I-K/4) D_j + A*/4 . +``` + +Induction gives `D_j A=I`, and subtracting the canonical fixed point +`A^+=K^(-1) A*` multiplies its error on the left by `I-K/4`. The +enclosure gives `||I-K/4||_2 < 63/64` and `||A^+||_2 < 3.02095` +(the latter is checked by squaring against the lower endpoint). +The initial error is less than `2^56`. Since `(63/64)^64<1/2`, +at `j=8192` the operator-norm error is less than `2^-72`, giving +`||D_8192||_2 < 3.021`. This yields bounded noise amplification for +an exact Gaussian-dyadic decoder at the first possible width as well +as all larger widths. The width and splitting proof in Sections 1–4 +uses no spectral bound. + +The construction concerns exact algebraic recovery. It supplies no +priced physical realization, new supplier or improvement in κ. The +rank failure at width 12 is an input from #7766. An inverse at any +smaller width could be padded to width 12 by Section 4, contradicting +that rank failure. The full +Clifford alphabet and production multiplier are not enumerated here. +The earlier width-17 construction and its general stabilizer result +retain their distinct scope. [Width-17 handoff #7798](https://github.com/CrocSwap/integer-mult-bounds/pull/7798). + +Clifford actions on Weyl operators, Bell coordinates, symplectic +transvections and character idempotents are classical. The projective +alphabet and complex threshold follow Ali Romman and the retained work +of alephnan and Nick Petalas. Prepared by **apoursh** with substantial +OpenAI Codex and separate agent assistance. Apache-2.0. diff --git a/research/clifford-bell-fibres/README.md b/research/clifford-bell-fibres/README.md new file mode 100644 index 0000000000..c3805ffcde --- /dev/null +++ b/research/clifford-bell-fibres/README.md @@ -0,0 +1,34 @@ +# Exact Gaussian-dyadic Clifford recovery at width 13 + +For the full four-qubit projective Clifford alphabet, **13 is the minimum tensor width for exact coefficient recovery over the Gaussian dyadics**. At width 13 an explicit left inverse of the normalized tensor map uses only coefficients in `Z[i,1/2]`. Tensoring each output row with its target's unit-norm single-copy functional extends it to every larger width. Ali Romman's complex rank obstruction at width 12 supplies the lower bound. The construction resolves all four widths left open by #7798. [Proof](PROOF.md) · [Complex threshold #7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766) · [Width-17 handoff #7798](https://github.com/CrocSwap/integer-mult-bounds/pull/7798) + +The observation is an arbitrary linear combination of `(vec(U)/4)^(tensor f)`, with one fixed Gaussian-dyadic representative per Clifford scalar coset. The proof constructs a linear decoder on the whole observation space and proves exact recovery on the image. It also implies full column rank after reduction modulo every odd Gaussian prime. The established width-17 threshold for all eight-qubit stabilizer rays concerns a larger alphabet. + +## Construction + +1. Use six Bell pairs to read which symplectic transformations carry one ordered tuple of labels to another. The thirteenth copy retains a matrix. A known Weyl correction removes phases depending on the chosen Pauli lift, exposing the sum of the unknown matrices over eight symplectic transformations. +2. Translate these sums to isolate one symplectic transformation at a time. The certificate checks all 1,024 characters of the binary symmetric shear group. For 576 characters, the subgroup average acts as the identity on the character component. For the other 448, a change of symplectic coordinates gives one quarter of that component. Multiplication by four completes the same reconstruction over the dyadics. +3. Within each recovered matrix, a normalized trace against each of its 256 possible Clifford representatives returns that representative's coefficient. + +Conditional on #7772's uniform spectral enclosure, the exact dyadic iteration from #7798 yields an inverse with Euclidean operator norm **below 3.021 at every width f ≥ 13**. This controls arbitrary additive observation error. The canonical least-squares map has odd denominators at width 13. The two decoders agree on the noiseless image and may differ on arbitrary observations. The physical cost of implementing either the initial decoder or the 8,192 iterations used for the norm bound remains open. This contribution makes no change to κ. [Stability proof](PROOF.md#5-stability-on-the-normalized-observations) · [Spectral bounds #7772](https://github.com/CrocSwap/integer-mult-bounds/pull/7772) · [Canonical obstruction #7792](https://github.com/CrocSwap/integer-mult-bounds/pull/7792) + +## Reproduce + +Run from the repository root with CPython 3.12 and the standard library. + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-bell-fibres +``` + +- `verify.py` constructs binary symplectic matrices, checks the eight-element stabilizer among all 64 candidate shears, and verifies every character identity using literal matrix conjugation. It also checks the Fourier resolution, failure controls and the numerical margins for the stability corollary. +- `independent_check.py` uses separate computational-basis four-qubit matrices. Three calibration frames cover 297 operator instances with different global phases and 6,144 within-fibre coefficient checks. A second experiment passes an actual mixture with 80 nonzero coefficients through the Bell measurements. It recovers all 2,048 coefficients on the restricted alphabet, including 1,968 zeros and deliberate cancellations. +- Both checkers run normally and under optimized Python. The proof supplies the full-alphabet statement. No full tensor matrix, production multiplier, external spectrum replay, human proof certification or formal-kernel check is included. [Replay commands](VERIFY.json) · [Pinned research inputs and context](SOURCES.json) + +## Credit and coordination + +Prepared by **apoursh** with substantial OpenAI Codex and separate agent assistance, under Apache-2.0. Ali Romman's work supplies the original complex threshold, spectral enclosure, Bell-sector analysis and canonical obstruction. The Pauli and character-theoretic lineage includes alephnan and Nick Petalas. The starting question and the dyadic stabilization iteration are from #7798. Projective Clifford actions, finite Fourier analysis and group-algebra idempotents are classical. The exact width-13 upper bound in Sections 1–4 has its own proof. [Bell-sector predecessor #7789](https://github.com/CrocSwap/integer-mult-bounds/pull/7789) · [Research claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19753161) · [Task scope and overlap](TASK.json) + +## Open next questions + +1. What does one transported Bell block cost at a named caller? Include coordinate access, precision, movement, workspace and cleanup before summing the cost of the full decoder. +2. Can a sparse, exact width-13 implementation reach a useful noise bound with fewer Gram applications? Start with the character sum for one output coefficient and quantify cancellations at a fixed input layout. diff --git a/research/clifford-bell-fibres/SOURCES.json b/research/clifford-bell-fibres/SOURCES.json new file mode 100644 index 0000000000..9f5c37fddc --- /dev/null +++ b/research/clifford-bell-fibres/SOURCES.json @@ -0,0 +1,50 @@ +{ + "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": 7798, + "head": "0ae10f215780296ca50142fd36fdf904b8c1b146", + "author": "apoursh", + "use": "Width-17 split, broader stabilizer lower bound, stability iteration and handoff." + }, + { + "pr": 7766, + "head": "d7c2dd1868c70f0addce2c0a4d3220149452f14b", + "author": "Ali Romman", + "use": "Complex rank failure at width 12 for sharpness." + }, + { + "pr": 7772, + "head": "1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2", + "author": "Ali Romman", + "use": "Uniform spectral bounds used only in the stability corollary." + }, + { + "pr": 7789, + "head": "a5aa2ae21ae68338390f584b8fca58ecba0df409", + "author": "Ali Romman", + "use": "Bell-line representation and spectral precedent." + }, + { + "pr": 7792, + "head": "9321c67e29c3c41a188154bc5c2add7d7802b694", + "author": "Ali Romman", + "use": "Canonical odd denominator comparison." + } + ] +} diff --git a/research/clifford-bell-fibres/TASK.json b/research/clifford-bell-fibres/TASK.json new file mode 100644 index 0000000000..b6cc7af58a --- /dev/null +++ b/research/clifford-bell-fibres/TASK.json @@ -0,0 +1,101 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "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, + "scope_status": "changed", + "scope_key": "cdee6027333168fe48af", + "selection_nonce": "a17f9801f64aa97efcb3e3d946183514", + "actual_scope": "Resolve the four remaining widths for the full four-qubit Clifford tensor map over Z[i,1/2], starting from PR7798's handoff.", + "scope_change_reason": "This narrows the historical audit card to a concrete recovery-alphabet question. The selected multiplier's five framework assumptions remain open.", + "bottleneck_link": "Determines whether exact coefficient recovery at the first possible width requires odd division. The resulting decoder's physical cost remains open.", + "stop_rule": "Stop at a source-specific split or obstruction, an independent literal phase check and a reproducible certificate for the residual subgroup averages.", + "outcome": "completed", + "author": "apoursh", + "ai_assistance": "Substantial OpenAI Codex and separate agent assistance in proof, review and independent implementation.", + "evidence": "PROOF.md derives the width-13 left inverse, padding, modular corollary and noise bound. verify.py covers 1,024 character certificates. independent_check.py uses literal matrices and a complete restricted mixture.", + "family_decision": "Use six Bell pairs and the single remaining matrix factor on the Clifford subset. The exact lower threshold for all eight-qubit stabilizer rays from PR7798 needs no revision.", + "overlap": "Reviewed #1163, #1166, #7798, #7789, #7792, #7772 and #7766. Live all-state PR title/body and recent handoff searches found no matching width-13 dyadic construction. The local overlap cache and sparse note search are incomplete.", + "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19753161", + "orientation": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY on upstream main. Revision 8 is historical relative to the selected PR7000 record.", + "open_questions": [ + { + "question": "Can the exact decoder at width 13 be evaluated efficiently on the observations supplied by a named caller?", + "why_it_matters": "The left inverse is specified by finite algebra, and the complete global group-algebra expansion is large.", + "first_step": "Price one transported Bell block including gathering the coordinates, finite precision, workspace and restoration.", + "blocked_by": "No costed implementation or compatible physical caller is supplied." + }, + { + "question": "How small can the noise amplification be with a sparse exact dyadic implementation at width 13?", + "why_it_matters": "The norm bound below 3.021 uses 8,192 dense Gram steps.", + "first_step": "On one fixed coset-sum implementation track coefficient cancellations before applying an iteration and compare with the certified norm.", + "blocked_by": "Availability and cost of compressed access to the actual input blocks are unknown." + } + ], + "upstream_refresh": { + "date_utc": "2026-11-19", + "entry": "pulled canonical main", + "pre_submission": "same commit", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "selected": "#7000 conditional κ=0.00363005817" + } +} diff --git a/research/clifford-bell-fibres/VERIFY.json b/research/clifford-bell-fibres/VERIFY.json new file mode 100644 index 0000000000..ece30349f4 --- /dev/null +++ b/research/clifford-bell-fibres/VERIFY.json @@ -0,0 +1,59 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Symplectic stabilizer, all 1,024 character identities, correction controls and norm margins" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Symplectic stabilizer, all 1,024 character identities, correction controls and norm margins under optimized Python" + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/independent_check.py" + ], + "timeout_seconds": 60, + "checks": "Literal four-qubit Bell phases, singleton correction and full restricted-mixture reconstruction" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/independent_check.py" + ], + "timeout_seconds": 60, + "checks": "Literal four-qubit Bell phases, singleton correction and full restricted-mixture reconstruction under optimized Python" + } + ] +} diff --git a/research/clifford-bell-fibres/independent_check.py b/research/clifford-bell-fibres/independent_check.py new file mode 100644 index 0000000000..3ea7d0b81d --- /dev/null +++ b/research/clifford-bell-fibres/independent_check.py @@ -0,0 +1,284 @@ +"""Check the degree-13 Bell measurement on literal four-qubit matrices. + +Matrices are sparse computational-basis columns of Gaussian integers with a +common positive denominator kept outside each frame. No primary checker or +predecessor code is imported. apoursh with substantial OpenAI Codex +assistance. Apache-2.0. +""" + +from functools import reduce +from operator import xor + +ZERO = (0, 0) +ONE = (1, 0) +ROOTS = (ONE, (0, 1), (-1, 0), (0, -1)) +TUPLE = (0, 16, 32, 64, 128, 8) # zero, Z1..Z4, X4 (bit 0 is qubit 1) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def mul(z, w): + return z[0] * w[0] - z[1] * w[1], z[1] * w[0] + z[0] * w[1] + + +def conj(z): + return z[0], -z[1] + + +def scale(z, n): + return z[0] * n, z[1] * n + + +def add_entry(result, index, z): + a, b = result.get(index, ZERO) + updated = (a + z[0], b + z[1]) + if updated == ZERO: + result.pop(index, None) + else: + result[index] = updated + + +def sign(z, j): + return (-1) ** ((z & j).bit_count() % 2) + + +def weyl(label): + x, z = label % 16, label // 16 + return [{j ^ x: (sign(z, j), 0)} for j in range(16)] + + +def multiply(left, right): + columns = [] + for col in right: + result = {} + for middle, a in col.items(): + for row, b in left[middle].items(): + add_entry(result, row, mul(b, a)) + columns.append(result) + return columns + + +def adjoint(u): + output = [{} for _ in range(16)] + for j, col in enumerate(u): + for i, value in col.items(): + output[i][j] = conj(value) + return output + + +def rotate(u, exponent): + return [{r: mul(z, ROOTS[exponent % 4]) for r, z in col.items()} for col in u] + + +def diagonal_cube(mask): + # The independent diagonal phases are CZ12, CZ13, CZ23. + pairs = ((1, 2), (1, 4), (2, 4)) + gate = [] + for j in range(16): + exponent = sum(1 for k, (a, b) in enumerate(pairs) + if mask & (1 << k) and j & a and j & b) + gate.append({j: ((-1) ** exponent, 0)}) + return gate + + +def hadamard(bit): + # The numerator of (1+i) [[1,1],[1,-1]] / 2 at one chosen bit. + return [{j & ~bit: (1, 1), j | bit: ((-1, -1) if j & bit else (1, 1))} + for j in range(16)] + + +def literal_action(u, denominator, label, *, bell): + """Expand U W_t U^T (Bell pair) or U W_t U^* (singleton correction).""" + x, z = label % 16, label // 16 + entries = {} + for j, col in enumerate(u): + for right, b in col.items(): + factor = scale(b if bell else conj(b), sign(z, j)) + for left, a in u[j ^ x].items(): + add_entry(entries, (left, right), mul(a, factor)) + require(len(entries) == 16, "image is not a signed Weyl matrix") + x_next, = [r for r, c in entries if c == 0] + scalar = entries[x_next, 0] + require(scalar in [scale(root, denominator ** 2) for root in ROOTS], + "incorrect scaled Bell amplitude") + phase = ROOTS.index((scalar[0] // denominator ** 2, scalar[1] // denominator ** 2)) + z_next = sum(1 << bit for bit in range(4) + if entries[x_next ^ (1 << bit), 1 << bit] != scalar) + require(all(entries.get((x_next ^ j, j)) == scale(scalar, sign(z_next, j)) + for j in range(16)), "wrong displacement or Walsh sign") + return x_next | (z_next << 4), phase + + +def add_scaled_matrix(output, u, alpha): + for j, col in enumerate(u): + for i, value in col.items(): + add_entry(output, (i, j), mul(alpha, value)) + + +def sandwich(entries, left, right): + """Multiply by W_left on the left and W_right^{-1} on the right.""" + return {(i ^ (left % 16), j ^ (right % 16)): + scale(z, sign(left // 16, i) * sign(right // 16, j)) + for (i, j), z in entries.items()} + + +def gauge(p, c): + return (p.bit_count() + c % 3) % 4 + + +def shifted(u, p, c): + return rotate(multiply(weyl(p), u), gauge(p, c)) + + +def frobenius(u, entries): + total = [0, 0] + for j, col in enumerate(u): + for i, z in col.items(): + term = mul(conj(z), entries.get((i, j), ZERO)) + total[0] += term[0] + total[1] += term[1] + return tuple(total) + + +def calibration(in_gate, d_in, out_gate, d_out): + t = [literal_action(in_gate, d_in, a, bell=True)[0] for a in TUPLE] + m = [literal_action(out_gate, d_out, a, bell=True)[0] for a in TUPLE] + w, w_next = reduce(xor, t), reduce(xor, m) + denominator = d_in * d_out + s1 = [{j: ROOTS[j & 1]} for j in range(16)] + # S1 fixes X4 Z1 Z2 Z3 Z4 as a label, but moves the Bell tuple. + shapes = [diagonal_cube(c) for c in range(8)] + [s1] + selected_p = (0, 1, 2, 4, 8, 17, 35, 81, 128, 194, 255) + detected = {} + coset_sum = {} + rho_values = set() + beta_phases = set() + gamma_phases = set() + invisible = wrong_single_weight = isolated_checks = 0 + for c, shape in enumerate(shapes): + u0 = multiply(out_gate, multiply(shape, adjoint(in_gate))) + individual = {} + weights = {} + for j, p in enumerate(selected_p): + u = shifted(u0, p, c) + # Include genuinely complex and nonuniform coefficients, and zero + # coefficients on the remaining 245 Paulis in each fibre. + alpha = (1 + (j + c) % 5, (2 * j + c) % 7 - 3) + weights[p] = alpha + add_scaled_matrix(individual, u, alpha) + images = [literal_action(u, denominator, a, bell=True) for a in t] + sw, gamma = literal_action(u, denominator, w, bell=False) + matches = [a for a, _ in images] == m + require(matches == (c < 8), "six pairs selected the wrong symplectic fibres") + if not matches: + invisible += 1 + wrong_single_weight += sw == w_next + continue + require(sw == w_next, "tuple sum and singleton weight disagree") + beta = sum(b for _, b in images) % 4 + rho_values.add((beta - gamma) % 4) + beta_phases.add(beta) + gamma_phases.add(gamma) + # Measured singleton numerator after the known 4^13 normalization + # is removed from the input tensor coordinates. + add_scaled_matrix(detected, u, mul(ROOTS[beta], alpha)) + add_scaled_matrix(coset_sum, u, alpha) + if c < 8: + # On a supplied individual X_R, extraction checks every coefficient, + # including the 245 making zero contributions to this mixture. + for p in range(256): + trace = frobenius(shifted(u0, p, c), individual) + require(trace == scale(weights.get(p, ZERO), 16 * denominator ** 2), + "incorrect Fourier extraction or representative phase") + isolated_checks += 1 + require(len(rho_values) == 1, "transport phase depends on a Pauli or cube lift") + rho, = rho_values + answer = {k: mul(z, ROOTS[rho]) for k, z in coset_sum.items()} + require(sandwich(detected, w_next, w) == answer and answer, + "literal singleton correction lost the unweighted coset sum") + require(invisible == len(selected_p) and wrong_single_weight == invisible, + "off-coset fixture did not exercise full-tuple filtering") + return (len(beta_phases), len(gamma_phases), rho, isolated_checks, + detected != answer, imaginary_phase(beta_phases | gamma_phases)) + + +def decode_cz_mixture(): + # H on the first three qubits turns the Z-shear stabilizer into X + # shears. Its intersection with the eight allowed CZ shapes is trivial. + frame = multiply(hadamard(1), multiply(hadamard(2), hadamard(4))) + t = [literal_action(frame, 8, a, bell=True)[0] for a in TUPLE] + w = reduce(xor, t) + buckets = {} + decoder = {} + weights = {} + for c in range(8): + gate = diagonal_cube(c) + seed = [literal_action(gate, 1, a, bell=True) for a in t] + target = tuple(a for a, _ in seed) + sw, gamma = literal_action(gate, 1, w, bell=False) + require(target not in decoder and sw == reduce(xor, target), + "two CZ fibres collide in the transverse frame") + decoder[target] = (c, sw, (sum(b for _, b in seed) - gamma) % 4) + for p in (0, 16, 1, 17, 33, 49, 2, 18, 34, 50): + # The first two terms give (I-Z1) CZ in each corrected fibre. + # Their diagonal contributions at basis zero cancel exactly. + if p in (0, 16): + alpha = scale(ROOTS[-gauge(p, c) % 4], 1 if p == 0 else -1) + else: + alpha = (1 + (p+c) % 5, (p+2*c) % 7 - 3) + weights[c, p] = alpha + u = shifted(gate, p, c) + images = [literal_action(u, 1, a, bell=True) for a in t] + observed_target = tuple(a for a, _ in images) + beta = sum(b for _, b in images) % 4 + add_scaled_matrix(buckets.setdefault(observed_target, {}), + u, mul(alpha, ROOTS[beta])) + require(len(buckets) == 8, "transverse frame failed to separate all fibres") + recovered = 0 + for observed_target, observation in buckets.items(): + c, sw, rho = decoder[observed_target] + corrected = sandwich(observation, sw, w) + matrix = {k: mul(z, ROOTS[-rho % 4]) for k, z in corrected.items()} + require((0, 0) not in matrix and (1, 1) in matrix, + "deliberate observable cancellation was lost") + for p in range(256): + result = frobenius(shifted(diagonal_cube(c), p, c), matrix) + require(result == scale(weights.get((c, p), ZERO), 16), + "failed to decode the complete mixed sparse alphabet") + recovered += 1 + return recovered + + +def imaginary_phase(phases): + return bool(phases & {1, 3}) + + +def main(): + identity = weyl(0) + s1 = [{j: ROOTS[j & 1]} for j in range(16)] + cnot = [{j ^ (2 if j & 8 else 0): ONE} for j in range(16)] + # Choose a dense output basis and a non-real input/output basis. The + # latter exercises the distinction between transpose and adjoint. + frames = [(identity, 1, identity, 1), + (identity, 1, multiply(s1, hadamard(8)), 2), + (multiply(s1, hadamard(1)), 2, multiply(hadamard(2), cnot), 2)] + results = [calibration(*frame) for frame in frames] + require(any(row[-2] for row in results), "omitting singleton correction escaped") + require(any(row[-1] for row in results), "no nonreal phase tested") + bell_s = literal_action(s1, 1, 0, bell=True) + adj_s = literal_action(s1, 1, 0, bell=False) + require(bell_s != adj_s, "using conjugate instead of transpose escaped") + complete = decode_cz_mixture() + print("PASS_LITERAL_SIX_BELL_SINGLETON", f"frames={len(frames)}", + f"input_operators={9 * 11 * len(frames)}", + f"weyl_extractions={sum(r[3] for r in results)}", + f"off_coset_same_weight={11 * len(frames)}", + f"mixture_coefficients={complete} active_mixture_coefficients=80", + f"transport_units={','.join(str(r[2]) for r in results)}") + + +if __name__ == "__main__": + main() diff --git a/research/clifford-bell-fibres/verify.py b/research/clifford-bell-fibres/verify.py new file mode 100644 index 0000000000..a58f81e8ec --- /dev/null +++ b/research/clifford-bell-fibres/verify.py @@ -0,0 +1,220 @@ +"""Check the width-13 group algebra certificate over Z[1/2]. + +All maps below are actual binary linear maps on four Z and four X bits. +apoursh, with substantial OpenAI Codex assistance. Apache-2.0. +""" + +from collections import Counter +from fractions import Fraction +from functools import cache +from itertools import combinations, combinations_with_replacement + + +STANDARD = tuple(1 << i for i in range(8)) +PAIRS = tuple(combinations_with_replacement(range(4), 2)) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def parity(value): + return value.bit_count() % 2 + + +def symp(a, b): + return parity((a & (b >> 4)) ^ ((a >> 4) & b)) + + +def q0(a): + return parity((a & 15) & (a >> 4)) + + +def linear(columns, mask): + image = 0 + while mask: + bit = mask & -mask + image ^= columns[bit.bit_length() - 1] + mask ^= bit + return image + + +def compose(a, b): + return tuple(linear(a, x) for x in b) + + +def span(rows): + return {linear(rows, mask) for mask in range(1 << len(rows))} + + +def shear(u, v): + return tuple(x ^ (symp(v, x) * u) ^ (symp(u, x) * v) for x in STANDARD) + + +def rank_one(u): + return tuple(x ^ (symp(u, x) * u) for x in STANDARD) + + +def commuting_group(generators): + members = [STANDARD] + for g in generators: + require(compose(g, g) == STANDARD, "generator is not an involution") + require(all(compose(e, g) == compose(g, e) for e in members), "nonabelian generators") + members.extend([compose(g, e) for e in members]) + require(len(set(members)) == len(members), "dependent group generators") + return tuple(members) + + +def alt_group(w): + require(len(span(w)) == 8 and all(symp(u, v) == 0 for u, v in combinations(w, 2)), + "W must be an isotropic three-plane") + return commuting_group([shear(u, v) for u, v in combinations(w, 2)]) + + +def seed_stabilizer(): + # Fixing D pointwise leaves only symmetric shears on its three dual axes. + generators = [rank_one(1 << i) for i in range(3)] + seed = (1, 2, 4) + candidates = commuting_group(generators + [shear(i, j) for i, j in combinations(seed, 2)]) + d = (*seed, 8, 128) + require(all(all(linear(g, b) == b for b in d) for g in candidates), "D moved") + fixed = {g for g in candidates if all(q0(linear(g, v)) == q0(v) for v in range(256))} + require(fixed == set(alt_group(seed)), "incorrect affine Bell tuple stabilizer") + return len(candidates), len(fixed) + + +def symmetric_data(): + generators = tuple(rank_one(1 << i) if i == j else shear(1 << i, 1 << j) + for i, j in PAIRS) + # Enumeration in bit-mask order, so each group member has its character address. + members = commuting_group(generators) + return generators, {g: mask for mask, g in enumerate(members)} + + +def quadratic_mask(vector): + # Address of the symmetric rank-one matrix vector * vector^T. + return sum(1 << k for k, (i, j) in enumerate(PAIRS) + if vector & (1 << i) and vector & (1 << j)) + + +def select_plane(values): + def polar(u, v): + return values[u ^ v] ^ values[u] ^ values[v] + + radical = [u for u in range(16) if all(not polar(u, v) for v in (1, 2, 4, 8))] + if len(radical) > 1: + for plane in combinations(range(1, 16), 3): + if len(span(plane)) == 8 and all(not polar(u, v) for u, v in combinations(plane, 2)): + return plane, len(radical) + raise ValueError("missing isotropic three-plane") + + r = next(v for v in range(1, 16) if values[v] == 0) + h = {v for v in range(16) if not polar(r, v)} + z2 = min(h - {0, r}) + # x4 is the covector killing H (nonzero on the fourth basis direction). + x4 = next(x for x in range(1, 16) if all(not parity(x & z) for z in h)) + return (r, z2, x4 << 4), 1 + + +def extend_basis(w): + # Produce a full symplectic change of coordinates carrying the seed to W. + z = list(w) + z.append(next(v for v in range(1, 256) if v not in span(z) and all(not symp(v, u) for u in z))) + x = [] + for k in range(4): + x.append(next(v for v in range(1, 256) + if all(symp(v, u) == int(k == j) for j, u in enumerate(z)) + and all(not symp(v, u) for u in x))) + columns = tuple(z + x) + require(len(span(columns)) == 256, "singular change of basis") + require(all(symp(columns[i], columns[j]) == symp(STANDARD[i], STANDARD[j]) + for i in range(8) for j in range(8)), "basis does not preserve the pairing") + return columns + + +def check_fourier_blocks(): + generators, addresses = symmetric_data() + seed = alt_group((1, 2, 4)) + + @cache + def checked_action(w): + g = extend_basis(w) + subgroup = alt_group(w) + require({compose(c, g) for c in subgroup} == {compose(g, c) for c in seed}, + "subgroup is not the asserted conjugate") + # Every element here is an involution. Compute all induced generator + # images by literal 8x8 composition, independent of the Q-selection rule. + return tuple((addresses.get(c), tuple(addresses[compose(compose(c, a), c)] for a in generators)) + for c in subgroup) + + by_radical = Counter() + stabilizer_sizes = Counter() + moved_characters = 0 + for character in range(1024): + values = tuple(parity(character & quadratic_mask(v)) for v in range(16)) + w, radical_size = select_plane(values) + weight = 0 + for address, induced in checked_action(w): + new_character = sum(parity(character & mask) << j for j, mask in enumerate(induced)) + if new_character != character: + moved_characters += 1 + continue + require(address is not None, "non-shear survived the Fourier sandwich") + weight += (-1) ** parity(address & character) + require(weight == (2 if radical_size == 1 else 8), "wrong subgroup average") + by_radical[radical_size] += 1 + stabilizer_sizes[weight] += 1 + require(by_radical == {16: 16, 4: 560, 1: 448}, "quadratic character census") + require(stabilizer_sizes == {8: 576, 2: 448} and moved_characters == 2688, + "incomplete sandwich coverage") + # Completeness of the actual Fourier masks and their inverse over the dyadics. + for address in range(1024): + weight = sum((-1) ** parity(address & ch) for ch in range(1024)) + require(weight == (1024 if address == 0 else 0), "Fourier resolution") + return moved_characters + + +def controls(): + # On a nonsingular alternating character every three-plane of L fails. + def hyperbolic(v): + return parity((v & 3) & (v >> 2)) + + for normal in range(1, 16): + plane = [v for v in range(16) if not parity(normal & v)] + require(any(hyperbolic(u ^ v) != (hyperbolic(u) ^ hyperbolic(v)) + for u, v in combinations(plane, 2)), "all-Z plane control") + # A nonsingular r with Q(r)=1 gives a transvection preserving Q, + # so the step discarding all off-diagonal terms would be false. + r = 5 + require(hyperbolic(r) == 1 and all(hyperbolic(v) == hyperbolic( + v ^ (r if hyperbolic(v ^ r) ^ hyperbolic(v) ^ hyperbolic(r) else 0)) + for v in range(16)), "anisotropic-r control") + # Removing one term from the normalized average produces an odd numerator. + require(sum((-1)**parity(ch) for ch in range(1023)) != 0, "missing character control") + + +def check_stability_bounds(): + # Apply the quoted PR7772 spectral enclosure; identification of its + # eigenvalues and all-width propagation are external mathematical inputs. + low = Fraction(470624175, 2**32) + high = Fraction(7841980575, 2**30) + translate_mass = Fraction(576 + 4 * 448, 8) + require(translate_mass == 296 and 4**12 * translate_mass < 2**33, "row norm") + n = 12128668876800 + require(n * (2**33)**2 < (2**55)**2, "matrix norm") + require(max(abs(1-low/4), abs(1-high/4)) < Fraction(63, 64), "contraction") + require(Fraction(63, 64)**64 < Fraction(1, 2), "iteration rate") + canonical_bound = Fraction(302095, 100000) + require(low * canonical_bound**2 > 1, "canonical norm") + require(8192 // 64 - 56 == 72 and canonical_bound + Fraction(1, 2**72) < Fraction(3021, 1000), + "noise margin") + + +if __name__ == "__main__": + count, fixed = seed_stabilizer() + moved = check_fourier_blocks() + controls() + check_stability_bounds() + print(f"PASS_CLIFFORD_BELL_FIBRES candidates={count} seed_stabilizer={fixed}" + f" characters=1024 full_sandwiches=576 quarter_sandwiches=448 moved_pairs={moved}")