Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
233 changes: 233 additions & 0 deletions research/clifford-width17/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,233 @@
# Dyadic interpolation of four-qubit Clifford tensors at width 17

Let `R = Z[i,1/2]`. Choose one Gaussian-dyadic unitary representative
`U_a` of each four-qubit Clifford coset modulo scalar powers of `i`.
Write `c_a = vec(U_a)/4` and let `A_f` have columns `c_a^(tensor f)`.
The convention `vec(U_a^(tensor f))/4^f` differs only by a coordinate
permutation. There are `N = 12,128,668,876,800` columns.

**Theorem.** At every integer width `f >= 17`, the recipe below gives a
matrix `B_f` over `R` such that `B_f A_f = I_N`. Each row of this
specified inverse has squared Euclidean norm `73,190,789,644,335,724`.
Using the reported spectral bounds of #7772, a finite dyadic iteration
gives another exact inverse with operator norm below `3.021`.
The proof also gives the exact complex independence threshold 17 for the
larger alphabet of *all* eight-qubit projective stabilizer states.
The four-qubit Clifford alphabet is a proper subset. Its least dyadic
width remains open between 13 and 17 inclusive, using the reported
complex threshold of [#7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766).

## 1. Recenter the target over the coefficient ring

Use computational labels `s,r in F_2^4` for the row and column of a
matrix. For a fixed target apply `U_a^* ⊗ I`, then the Bell-basis change

```text
D |s,r> = (1/4) sum_z (-1)^(r·z) |s+r,z>.
```

This is a reversible binary relabeling followed by four Hadamards on the
second register. Their combined coefficient is exactly `1/4`. Thus
`T_a = D(U_a^* ⊗ I)` is unitary, Clifford and Gaussian-dyadic.
It sends `c_a` to `e_0`, since the character sum of `(-1)^(r·z)` over
the sixteen values of `r` vanishes for every nonzero `z`. Each `c_b`
comes from the four Bell pairs `vec(I)/4` by a Clifford on the first
register. Hence `v = T_a c_b` is an eight-qubit stabilizer vector. Its
ray equals that of `e_0` precisely when `U_b` is proportional to `U_a`.
A scalar of modulus one in `R` is a power of `i`: if
`h²+j²=2^(2l)` with `l>0`, reduction modulo four forces both
`h,j` even, and descent gives the four units. Thus the chosen cosets
agree exactly in this case. With `a=b` the recentering gives `e_0`
with coefficient exactly one.

## 2. The phases on a stabilizer support

An eight-qubit stabilizer vector has support an affine subspace of
`V=F_2^8`. If it contains zero, its support is a linear subspace `A`
and the coefficients restricted to any independent directions
`b_1,...,b_k in A` have the form

```text
v_(sum_j t_j b_j) / v_0 = i^q(t),
q(t) = sum_j h_j t_j + 2 sum_(j<l) g_jl t_j t_l (mod 4).
```

Here `h_j in Z/4`, `g_jl in F_2`, and the bits `t_j` are represented
by zero or one. To see this directly, project the eight-dimensional
binary stabilizer onto its Pauli X-shifts, with image `H` of dimension
`h`. The kernel consists of `8-h` independent diagonal Z constraints.
They restrict nonzero amplitudes to a coset of `H`, because their
labels annihilate `H` by commutation and have dimension `8-h`.
An operator with shift `b` transports every amplitude to its translate
by `b`, with a nonzero phase. The support is nonempty and is therefore
the whole coset. When it contains zero, select a stabilizer element
`i^c X^b Z^z` for each basis direction used above. Moving from zero
along these directions in a fixed order gives the product of the local
phases `i^c` and signs `(-1)^(z·x)` at the previously reached points
`x`. The resulting exponent has the displayed form. This derivation
also permits supports of dimension zero and arbitrary global phases.
The affine quadratic normal form is classical. See [Dehaene and De Moor,
Theorem 5](https://arxiv.org/abs/quant-ph/0304125).

## 3. One ordered monomial per binary subspace

Take the eight rows of a binary length-16 generator matrix `G` for
`RM(1,3) ⊕ RM(1,3)`. In each length-eight block use the evaluations of
`y_1,y_2,y_3,1`, in that order, on the eight binary triples. Each block has rank four.
Each row has weight four or eight and each pair of distinct rows has
even overlap. Distinct blocks have disjoint support.

For each linear subspace `K <= V` choose an ordered basis
`b_1,...,b_k`, for instance its reduced row-echelon basis. Using the
first `k` rows of `G`, form the sixteen coordinate labels

```text
x_t(K) = sum_(j=1)^k G_(j,t) b_j, 1 <= t <= 16,
M_K(v) = product_(t=1)^16 v_(x_t(K)).
```

The labels span `K`, since the selected rows are independent. If
`v_0 != 0` with support `A`, this monomial vanishes unless `K <= A`.
For `K <= A`, sum the phase exponent of Section 2 across the sixteen
columns. Each linear coefficient is multiplied by a row weight divisible
by four; each quadratic coefficient already has a factor of two and
is multiplied by an even overlap. Hence `M_K(v) = v_0^16`. At `k=0`
all sixteen labels are zero, as required.

Put `mu_k = (-1)^k 2^(k(k-1)/2)`, the Möbius coefficient from zero
to a `k`-dimensional binary subspace. Explicitly, if `A` has dimension
`r`, the binary Gaussian binomial identity gives

```text
sum_(K<=A) mu_dim(K) = product_(j=0)^(r-1) (1 - 2^j) = 1[r=0].
```

This identity also follows by induction on `r` from the Gaussian
binomial recursion. For `f >= 17` set

```text
P_f(v) = v_0^(f-16) sum_(K<=V) mu_dim(K) M_K(v).
```

If `v_0=0`, the positive exponent kills every term. Otherwise the
preceding sum gives `P_f(v) = v_0^f 1[A={0}]`. In particular,
`P_f(T_a c_b) = 1[a=b]`.

Use one **ordered** tensor coordinate for each term, consisting of
`f-16` zero labels followed by the listed sixteen labels. Put coefficient
`mu_dim(K)` on that coordinate and zero elsewhere, obtaining a row
`b`. Different `K` produce different words because their labels span
different subspaces. No symmetrization or factorial division occurs.
The row `b T_a^(tensor f)` evaluates the interpolant on the observation
coordinates of the normalized map. This applies the ordered-word lift
in recentered coordinates before the unitary change of basis.
Stacking the rows yields `B_f`
over `R`.

The number of subspaces in dimensions 0 through 8 is
`(1,255,10795,97155,200787,97155,10795,255,1)`. The disjoint tensor
coordinates and the unitarity of the recentering give

```text
||b T_a^(tensor f)||_2² = sum_(k=0)^8 [8 choose k]_2 2^(k(k-1))
= 73,190,789,644,335,724.
```

In particular, for Euclidean noise `e` on the normalized observations,
each recovered coefficient has error at most `||b||_2 ||e||_2`, and
`||B_f e||_2 <= sqrt(N) ||b||_2 ||e||_2`.

## 4. Exact dyadic stabilization

Fix `A=A_f` and start with `D_0=B_f`. The following corollary uses
the all-width spectral enclosure of Ali Romman's [#7772, pinned
proof](https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/PROOF.md);
the interpolation theorem itself is independent of those spectra.
For `G=A* A` its two bounds are `l=470624175/2^32` and
`u=7841980575/2^30`. Apply the classical Landweber (Richardson
normal-equation) iteration with dyadic step:

```text
H = I - G/4,
D_(j+1) = H D_j + A*/4.
```

Every entry remains in `R`. If `D_j A = I`, then `D_(j+1) A = H+G/4=I`,
so each iterate is already an exact left inverse. The complex canonical
inverse `A^+ = G^(-1) A*` is a fixed point. Consequently
`D_j-A^+ = H^j (D_0-A^+)`. Since `1/16 < l <= u < 15/2`,
`||H||_2 < 63/64`. Section 3 and `||A^+||_2 <= 1/sqrt(l)` give
`||D_0-A^+||_2 <= sqrt(N) ||b||_2 + 1/sqrt(l) < 2^50`.
As `(64/63)^64 >= 1 + 64/63 > 2`, the choice `j=8192` yields
`||D_j-A^+||_2 < 2^-78`. For the numerical margin,
`302095² × 470624175 - 100000² × 2^32 = 142959244679375 > 0`.
Thus `||D_j||_2 < 302095/100000 + 2^-78 < 3.021`. This bound applies
to arbitrary Euclidean perturbations of the normalized observations.
The huge Gram multiplication and its precision, storage, movement and
restoration costs have no complete caller invoice here.

## 5. Sharpness for all eight-qubit stabilizer rays

Clifford transitivity sends any target stabilizer ray to that of
`e_0`. For example, reverse a stabilizer preparation circuit; when a
dyadic gate lift is desired, a single Hadamard can be rephased as
`(1+i)/2 * [[1,1],[1,-1]]`. The same polynomial then separates each target
from all other stabilizer rays; rescale its nonzero target value to one.
Thus their tensor columns are independent for `f >= 17`.

Suppose a degree-16 homogeneous polynomial separated `e_0` from every
other stabilizer ray with target value one. Any smaller-degree separator
could be padded by a power of `v_0` to meet this premise. Average the
polynomial over all diagonal Clifford phases `i^q(x)` of Section 2
on the full space `V`. These fix `e_0` and permute stabilizer rays,
so the average is still a separator. The phase generators allow every
linear coefficient modulo four and every cross sign independently.
For a degree-16 monomial with binary coordinate labels `x_1,...,x_16`,
the average survives only if each coordinate row of its `8 × 16`
label matrix has weight divisible by four and each pair overlaps evenly.
These rows and the length-16 all-ones row therefore span a self-orthogonal
binary space of dimension at most eight. The affine dimension of the
sixteen labels is the rank of this augmented matrix minus one. It is
at most seven.

For every nonempty affine subspace `A`, its indicator vector is
proportional to a stabilizer state: prepare a uniform superposition on
independent coordinates, extend its basis by an invertible binary map,
and translate. Evaluating a surviving monomial on this indicator gives
`1[F contained in A]` where `F` is the affine span of its labels.
Thus the averaged polynomial would express `1[A={0}]` as a combination
of these incidence functions with `dim F <= 7`. On the finite poset of
nonempty affine subspaces the full incidence matrix is unit triangular
in any inclusion-respecting order. Its expansion is unique. The
coefficient on `F` in the desired expansion is zero if `0` lies outside
`F` and `mu_dim(F)` otherwise, by the sum in Section 3. In particular
the coefficient on `V` is `2^28`, a contradiction. This proves the
stated threshold for the enlarged alphabet. The diagonal phases in this
argument can move a Clifford Choi ray outside the recentered Choi set.
Consequently this lower bound supplies no obstruction at widths 13–16
for the four-qubit problem.

## Attribution

The zero-quadratic-phase tuple method and its relation to doubly even
codes were developed in the project by Ali Romman and Nick Petalas.
The proof above uses their witness-code idea for an interpolation
problem, together with classical Möbius inversion and the stabilizer
normal form. [Nine-axis proof #5635](https://github.com/CrocSwap/integer-mult-bounds/pull/5635)
and [zero-phase witness lengths #5902](https://github.com/CrocSwap/integer-mult-bounds/pull/5902).

Ali Romman supplied the four-qubit canonical odd-denominator obstruction,
building on the Clifford work of alephnan and the character projections
of Nick Petalas. The earlier dyadic inverse of apoursh provided the
width-256 handoff. Those results retain their respective attribution.
[Canonical decoder #7792](https://github.com/CrocSwap/integer-mult-bounds/pull/7792)
and [prior interpolant #7797](https://github.com/CrocSwap/integer-mult-bounds/pull/7797).
Gross, Nezami and Walter describe the complex span projector for stabilizer
tensor powers in [Theorem 5.6](https://arxiv.org/abs/1712.08628).
Chang, Caro, Larocca and West use the quadratic-phase characters in their
[Eqs. 7–9](https://arxiv.org/html/2609.10974v1), and Nebe, Rains and
Sloane relate Clifford invariants to [self-dual code weight
enumerators](https://arxiv.org/abs/math/0001038).
We make no literature-priority claim for the complex threshold.
Prepared by **apoursh** with substantial OpenAI Codex and separate agent
assistance. Apache-2.0.
34 changes: 34 additions & 0 deletions research/clifford-width17/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,34 @@
# Gaussian-dyadic four-qubit Clifford recovery at width 17

For the normalized tensor columns of the full four-qubit projective Clifford alphabet, every integer width **f ≥ 17** admits an exact left inverse over **Z[i,1/2]**. The previous sufficient width was 256. The reported complex threshold is 13, leaving four widths, 13 through 16, where Gaussian-dyadic recovery remains open. For the larger alphabet of all eight-qubit stabilizer rays, the complex independence threshold is exactly 17. [Previous dyadic inverse #7797](https://github.com/CrocSwap/integer-mult-bounds/pull/7797) · [Complex threshold #7766](https://github.com/CrocSwap/integer-mult-bounds/pull/7766)

The normalized observation is a linear combination of columns `(vec(U)/4)^(tensor f)`, with one fixed representative per scalar coset. For each target, a change to Bell coordinates sends that column's single-copy state to the origin basis vector. A length-16 binary code cancels the quadratic phases on each linear subspace of the support. Möbius inversion isolates the target. The seventeenth coordinate kills supports missing the origin. Dropping it gives a false positive even on a four-qubit Clifford, as the checker demonstrates with one rephased Hadamard and three copies of HS. [Construction and lower bound](PROOF.md)

The resulting ordered tensor row has 417,199 nonzero entries before the change of basis and squared Euclidean norm 73,190,789,644,335,724. Starting from this exact inverse, dyadic Richardson iterations preserve exact recovery. Using the uniform spectral bounds of Ali Romman's #7772, 8,192 steps give a second exact inverse within **2⁻⁷⁸** of the canonical decoder in operator norm. Its noise amplification is **below 3.021** on arbitrary normalized observations. This estimate uses #7772's spectral theorem. The width-17 construction and the larger-alphabet lower bound are self-contained. [Stability proof](PROOF.md#4-exact-dyadic-stabilization) · [Pinned spectral result](https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/RESULT.json)

These are algebraic results. The Gram matrix has more than 12 trillion columns. No complete physical evaluation, storage, precision or routing cost is known for this decoder, and no change to the selected multiplication exponent κ is claimed.

## 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-width17
```

- `verify.py` checks seven literal four-qubit Clifford matrices, their 49 ordered recenterings, and all 417,199 subspaces on a full-support example. It reconstructs the squared row norm and checks five faulty variants.
- `independent_check.py` builds the 24-element embedded one-qubit projective alphabet and tests 9,216 normalized identities including all four scalar phases at widths 17–20. It expands 1,094 tensor coefficients for two target rows and checks 48 literal contractions. It rejects three mutations and imports neither other checker.
- `check_stability.py` authenticates the retained #7772 numerical receipt, checks its 81 spectral rows and proves the numerical margins by exact arithmetic. A small normalized matrix checks the iteration and its error recurrence through nine successive exact inverses.

Each checker runs normally and under optimized Python. The proofs cover the full alphabets. The replays use finite fixtures and never materialize the full Clifford tensor map or the 8,192-step dense decoder. The spectral identification, all-width propagation and the complex threshold from #7766 are attributed inputs. The only external research data consumed by the checks are bundled in `references/conditioning-result.json`. [Replay manifest](VERIFY.json) · [Sources and credit](SOURCES.json)

## Research context and credit

Prepared by **apoursh** with substantial OpenAI Codex and separate agent assistance under Apache-2.0. Ali Romman's canonical obstruction motivated the alternative decoder question. His work and Nick Petalas's work on code-based phase witnesses are predecessors to the present construction. Their Clifford and character-table sources retain the credit to alephnan and other contributors. The proof cites the classical stabilizer normal form and related work on Clifford invariants and tensor powers. [Canonical obstruction #7792](https://github.com/CrocSwap/integer-mult-bounds/pull/7792) · [Phase witnesses #5635](https://github.com/CrocSwap/integer-mult-bounds/pull/5635) · [Doubly-even codes #5902](https://github.com/CrocSwap/integer-mult-bounds/pull/5902)

This follows the intermediate-width handoff from #7797 on upstream `e54523517d0f03e58352e647c403a5af3e525a57`. The historical revision-8 audit card concerns a selected multiplier assumption. This follow-up addresses the algebraic feasibility of the proposed decoder and leaves those assumptions open. [Public claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19752782) · [Task and overlap record](TASK.json)

## Open next questions

1. Does the Clifford subset admit a Gaussian-dyadic left inverse at width 16, or even at 13? Start by restricting the incidence equations to the maximally entangled Choi rays. The diagonal phase averaging used for the larger-alphabet lower bound requires a family closed under those phases.
2. Is stable exact recovery affordable at one named caller? Price a single Gram application, including coefficient precision, movement, scratch space and restoration, before extrapolating to the full iteration.
66 changes: 66 additions & 0 deletions research/clifford-width17/SOURCES.json
Original file line number Diff line number Diff line change
@@ -0,0 +1,66 @@
{
"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"
}
],
"context_only": [
{
"pr": 7797,
"head": "9d3237a6308228145f1c26dc349f18d5c857bb41",
"credit": "apoursh",
"use": "Previous dyadic sufficient width and intermediate-width question."
},
{
"pr": 7792,
"head": "9321c67e29c3c41a188154bc5c2add7d7802b694",
"credit": "Ali Romman",
"use": "Canonical odd-division result and alternative decoder question."
},
{
"pr": 7788,
"head": "9a8ce06644700ffa576d99316450bcb52835d6dc",
"credit": "Ali Romman",
"use": "Normalization and complex spectral context."
},
{
"pr": 5635,
"head": "bd04d907995da4480d07099bafa4d44396caec0b",
"credit": "Ali Romman",
"use": "Related phase-neutral native monomial tests."
},
{
"pr": 5902,
"head": "dedb8bd4a53ecf7b36975941a872173ed8f2a1ba",
"credit": "Nick Petalas",
"use": "Related doubly-even code constructions for zero-phase witnesses."
},
{
"pr": 7766,
"head": "d7c2dd1868c70f0addce2c0a4d3220149452f14b",
"credit": "Ali Romman",
"use": "Reported full four-qubit complex threshold 13."
}
],
"retained_spectrum": {
"credit": "Ali Romman, retaining Nick Petalas and alephnan's predecessor work",
"pr": 7772,
"head": "1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2",
"url": "https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/RESULT.json",
"local_path": "references/conditioning-result.json",
"original_git_blob": "039f22ba0bfec63c02fb3a97959766b8ec3a1bfa",
"sha256": "d032d5e63820f4ffe246d21adcd8d272f04dfd635a6fc519c4a81a366ca41d49",
"use": "Unmodified numerical receipt for the stability corollary. Spectral identification and its propagation in width are inputs from PR7772."
}
}
Loading
Loading