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
165 changes: 165 additions & 0 deletions research/clifford-transported-fibre-gram/CLASS-ALGEBRA.json

Large diffs are not rendered by default.

23 changes: 23 additions & 0 deletions research/clifford-transported-fibre-gram/CLASS-ALGEBRA.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,23 @@
# Recognizing relative classes and compiling the central kernel

Use columns in the four-qubit binary Pauli convention. Bits 0 through 3 pair with bits 4 through 7. For each symplectic map $S$ and each of the 256 vectors $v$, find the first monic linear dependence of the sequence $v,Sv,\ldots$ by binary elimination. Record its polynomial and the bits $\langle v,S^jv\rangle$ through that degree, including the final bit. A symplectic conjugation permutes the vectors and preserves both quantities. The resulting histogram is therefore constant on each conjugacy class.

The included native representatives cover all 81 ordinary classes of $G=\mathrm{Sp}(8,2)$, of order 47,377,612,800. Their histograms are pairwise distinct. This finite check proves that each accepted symplectic input has an unambiguous class label. The two ordinary columns that coincide across every rationalized character are combined for the central calculation. The other 79 columns stand alone. Thus relative maps supplied by the caller can be located in the rational table by evaluating a histogram, with no group enumeration.

Let $n_j$ be the rational-class sizes, $r_B$ a sum of the ordinary characters in Galois orbit $B$, and $d_B$ the common constituent degree. Orthogonality gives the orbit length $m_B=\sum_j n_jr_B(j)^2/|G|$ and $d_B=r_B(1)/m_B$. For per-element coefficients constant on rational classes, the central character transform and its inverse are

$$
T_{Bj}=n_jr_B(j)/r_B(1),\qquad (T^{-1})_{jB}=d_Br_B(j)/|G|.
$$

All packet sums are real on these classes. Put $F_j=(-64)^{\dim\operatorname{Fix}(S_j)}$. The integer class matrix is $M=T^{-1}\operatorname{diag}(TF)T$. Its column at the identity is $F$. The width-13 Gram operator uses $M/16^{12}$. Apply powers or scalar polynomials to class coefficients in this 80-dimensional space. Use the resulting coefficient at the relative class for each requested source/target pair.

`native_classes.g` obtains ordinary representatives and character values directly from the natural group acting faithfully on the 255 nonzero vectors, using GAP 4.14 (The GAP Group). Reversing the order of the high four coordinates transports the native antidiagonal pairing to the Pauli convention. The class ordering is derived from the histograms. An optional rebuild compares signatures, sizes, fixed dimensions and every packet entry, so arbitrary choices of representatives may vary. From this directory run

```sh
gap -A -q -b -T native_classes.g > /tmp/sp8-classes.json
python3.12 -IB build_classes.py /tmp/sp8-classes.json
python3.12 -IB check_classes.py
```

The registered Python replay also checks 405 changes of symplectic basis, packet orthogonality, the adjoint identity $n_iM_{ij}=n_jM_{ji}$, all character eigenvectors, the identity coefficient of the squared kernel and the two width-13 spectral endpoints.
45 changes: 45 additions & 0 deletions research/clifford-transported-fibre-gram/PROOF.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,45 @@
# Fibre coordinates and the width-13 normal operator

Let $G=\operatorname{Sp}(8,2)$ and $W_p=X^xZ^z$ for $p=16x+z$. Fix $U_S$ for each $S\in G$ using the transvection word returned by the #7800 binary reduction. For an axis $a$, use the Gaussian-dyadic unitary $R_a=(1+i)(I+iP_a)/2$, $P_a=i^{x_a\cdot z_a\bmod2}W_a$. A word in application order $a_1,\ldots,a_\ell$ gives $U_S=R_{a_\ell}\cdots R_{a_1}$. Each word has $\ell\le16$. Our coefficient indexed by $(S,p)$ refers to the absolute lift $V_{S,p}=W_p U_S$. Define $A$ with columns $(\operatorname{vec}V_{S,p}/4)^{\otimes13}$, using the computational row/column order. All inner products are conjugate-linear in the first entry. [Pinned Bell lifts and projective-coordinate conventions](https://github.com/apoursh/integer-mult-bounds/blob/fdc90699f4a64139ed6d84cdbf9a606ff0ccd32e/research/clifford-sparse-row/PROOF.md)

## Read out a batch on one observation chart

Consider the #7800 Bell decoder $B$. At a raw address denote the twelve 4-bit shifts of its adjacent pairs by $s$, the twelve free second nibbles by $v$, and the two singleton nibbles by $y$. Compute the partial Walsh transform $T(s,w,y)=\sum_v(-1)^{w\cdot v}Y(s,v,y)$. For a supplied affine-quadratic chart, #7813 produces a common complex scalar, affine support equations and a quadratic phase function for $T$ on its support. Its restrictions to the singleton directions have the same kernel $U$ of dimension $e\le8$ at every choice of $(s,w)$. Each translated and character-modulated nonempty slice fits in one Fourier bin of a coset of $U$ after removing a common quadratic phase. These data depend only on the chart. [Predecessor elimination and bin construction](https://github.com/apoursh/integer-mult-bounds/blob/65573785774c6bbac12485a4d90cd82778d25e36/research/clifford-compact-pauli-fibre/PROOF.md)

Start with the 4,265 identity-fibre records $(I,J,n,\delta)$, where $I,J$ are input/output six-tuples, $n$ is the integer numerator and $i^\delta$ the compiler correction. On the output labels compute two tables using the fixed word for $S$. Write $U_S W_u U_S^*=i^{\gamma(u)}W_{Su}$ and $U_SW_tU_S^\mathsf{T}=i^{\theta(t)}W_{L(t)}$. The latter label action is affine. Transport replaces $J$ by $(L(t):t\in J)$ and changes the correction to

$$\delta' = \delta+\gamma(\mathop{\bigoplus} J)-\sum_{t\in J}\theta(t)\pmod4.$$

Indeed the six Bell phases multiply, and removing the ordinary Weyl phase on their sum gives the block transport phase. The correction undoes this phase. Six labels cancel the affine offset in their XOR. The ratio is independent of lifting the same symplectic map through a Pauli and a Gaussian unit: a Pauli contributes the sum of the six conjugation signs, which is the sign on their XOR, and the sixth power of its squared unit is one. Thus this traversal gives the same records as composing the output symplectic maps before independently choosing their lifts. The correctness extends to arbitrary chart amplitudes because the two linear functionals agree term by term.

Write $(x_o,z_o)=\bigoplus J'$ and $(x_i,z_i)=\bigoplus I$. The corrected singleton entry at $y+(x_o,x_i)$ gets the raw entry at $y$ with sign $(-1)^{(z_o,z_i)\cdot y}$. Both translations and the constant $i^{\delta'}$ are allowed by the shared bin calculation. After the per-coset transforms, chirp rotations and the common scalar, the compiler produces its corrected $16\times16$ target matrix. Right multiply by $U_S^*$ and take the sixteen length-16 Walsh transforms of its shifted diagonals to extract the trace against every $W_p U_S$. In the raw-sum convention of #7813 the final denominator is $4096$, from the Bell factor $4$, compiler denominator $1024$ and trace division by $16$, in addition to the supplied chart denominator and lift denominator. Tensoring each specified absolute lift thirteen times gives the corresponding one-hot complex coefficient. The procedure also evaluates $BY$ off the image of $A$. [Executable](readout.py) · [Direct off-image and gauge checks](verify_readout.py)

One batch performs one Gauss sum in at most 48 variables and one chart/singleton basis construction. There are $512\ell$ elementary label/phase steps to tabulate a target, twelve label fields per read, at most 4,265 signed bin updates and $256(e+4)$ complex Walsh additions/subtractions per target. Each of the $\ell$ right-lift factors needs 256 two-term Gaussian combinations, followed by a common $(1\pm i)/2$ per entry. These counts exclude binary section solves, phase evaluation, phase rotations, reading the chart/circuit and writing 256 complex coefficients per target. All raw-observation access is through the supplied chart; the circuit constructor reads its specification once. Each unrotated singleton component before the common chart scalar has magnitude at most $12{,}800$ by the sum of absolute weights. A lift factor can increase an integer numerator component by at most four and adds one denominator bit. The final trace adds at most four numerator bits. Calls on separate pieces of a linear combination can be added with their actual complex weights.

## An exact scalar convolution on every matrix entry

For a coefficient vector $c$ write $M_T=\sum_b c_{T,b}V_{T,b}$. The inverse is $c_{T,b}=\operatorname{Tr}(V_{T,b}^*M_T)/16$, by orthogonality of the $W_b$. This is a scaled isometry with $\lVert M_T\rVert_F^2=16\sum_b|c_{T,b}|^2$.

For $D=V_{S,p}^*V_{T,b}$ put $\tau=\operatorname{Tr}D$, $g=S^{-1}T$, and $k=\dim\ker(g-I)$. The trace of conjugation by $D$ on all matrices equals $|\tau|^2$. In the Weyl basis it equals the sum of the signs on the fixed Weyl labels. Indeed a fixed label's conjugation phase squares to one since its square is scalar. These signs form a character on the fixed subspace because two Weyl labels multiply to their sum up to scalar. The sum is either zero or $2^k$. In the latter case $\tau\in\mathbb Z[i,1/2]$ has this norm and equals a Gaussian unit times $(1+i)^k$: clear powers of two and factor in $\mathbb Z[i]$, using $2=-i(1+i)^2$. Hence $\tau^4=(-4)^k$ if it is nonzero. In both cases $\tau^{13}=(-64)^k\tau$.

It follows that $K=A^*A$ has coefficient entry $(\tau/16)^{13}=16^{-12}(-64)^k\operatorname{Tr}(V_{S,p}^*V_{T,b})/16$. Substituting into the inverse coordinate formula gives, for **every** $c$,

$$M_{Kc}(S)=\sum_{T\in G} f(S^{-1}T)M_c(T),\qquad f(g)=16^{-12}(-64)^{\dim\operatorname{Fix}(g)}.$$

The matrix entries of $M_c$ therefore give 256 independent copies of a scalar central convolution. The group size is 47,377,612,800. The nonzero/zero Pauli-trace pattern, its complex phases and cancellations all survive the change of coordinates. Computing the single-step weight needs only an eight-column binary rank since $\ker(S^{-1}T-I)=\ker(T-S)$.

## Compile a complete filter before receiving its input

In an irreducible character $\chi$ of degree $d$, convolution by $f$ has eigenvalue $\lambda_\chi=\sum_g f(g)\chi(g)/d$. The real rational packet sums in the accompanying table suffice, since inversion preserves $f$, Galois-conjugate characters have the same rational eigenvalue here, and $\chi(g^{-1})=\overline{\chi(g)}$. For a function $H$ on the 52 distinct eigenvalues the scalar kernel of $H(K)$ is

$$h(g)=|G|^{-1}\sum_{\chi}d\,H(\lambda_\chi)\chi(g^{-1}).$$

For a packet of size $n$ use its character sum, whose value at the identity is $nd$, and keep the same constituent degree $d$ in the inverse transform. This gives at most 80 dot products of length 80. Concrete eight-column inputs are recognized in the same class order by the native certificate. The independent spectral multiplicity check uses $\sum_{\chi:\lambda_\chi=\lambda}d^2$ on the quotient, with an additional factor of 256 for the original Gram. [Geometric class lookup and regeneration](CLASS-ALGEBRA.md) · [Spectrum from #7772](https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/RESULT.json)

Taking $H(\lambda)=1/\lambda$ gives the exact inverse Gram kernel because all levels are positive. For one of the #7809 schedules put $p(X)=\prod_j(1-h_jX)$ and $q(X)=(1-p(X))/X$. Starting at $d_0$ with supplied $t$, each update is $d\leftarrow d+h_j(t-Kd)$. Induction gives the final value $p(K)d_0+q(K)t$. Thus two scalar kernels per schedule suffice, including its odd-denominator last shift where prescribed. The verifier independently multiplies the actual 51 or 52 integral class operators with rational step sizes, checks each of the 80 residual entries, and verifies $Kq+p=I$ and $KK^{-1}=I$ as exact class functions. [Pinned schedules](https://github.com/apoursh/integer-mult-bounds/blob/7efc2c67b32e305d20e484dc3afa9229ab119269/research/clifford-accelerated-dyadic-decoder/PROOF.md) · [Consumer and filters](gram.py) · [Checks](verify_gram.py)

## Cost on named coefficient blocks

An input dictionary denotes complete support in its named fibres; omitted fibres are exactly zero. Count $m$ supplied 256-entry blocks across all input dictionaries, $u$ distinct named source fibres in their union and $r$ distinct requested output fibres. Synthesize the $m$ matrices once, using sixteen length-16 Walsh transforms plus a lift for each. Each output needs at most $u$ relative class queries (or $u$ binary ranks for a single Gram application), $256m$ real-weight/complex-entry multiply-adds, and one adjoint lift followed by sixteen length-16 transforms. Each block change thus costs $1024$ complex Walsh additions and $256\ell$ two-term lift combinations. A zero or shared input/output may reduce work. The input contains up to $256m$ complex values plus eight 8-bit columns per named target; output size is $256r$ complex values. The example programs store source matrices and output blocks, the fixed class inventory or Bell read list where applicable, and ordinary header/work arrays. A query has no loop over unlisted intermediate group elements, even when the mathematically intermediate vectors are dense. All targets can be named, incurring their output size. [Block representation and executable](gram.py)

Exact coefficient sizes are measurable. Over *all* 80 classes take the least common denominator across the kernels used by an action and use that denominator for every numerator. Its bit length and the maximum absolute numerator bit length are respectively $(145,145)$ for $K^{-1}$, $(11381,11381)$ for the 51-step pair, and $(7500,7500)$ for the 52-step pair. The Gram itself admits denominator $16^{12}$. Suppose supplied real and imaginary components have a shared positive denominator $D$ and numerator magnitude at most $2^B$. Let $L\le16$ be the largest lift length, $H$ the chosen common kernel denominator and $J$ the largest numerator bit length. An unreduced common denominator for a returned component is $D H 2^{2L+4}$. Its numerator magnitude is bounded by $\max(1,m)2^{B+8+4L+J}$: each Walsh bank contributes a factor of 16, each lift at most $4^L$ to each component of its numerator, and the scalar sum contributes at most $m2^J$. Shorter lift denominators can be padded to $2^L$ within the same bound. These are arithmetic/word counts on supplied blocks; $A^*y$ and $By$ for a general observation may both have dense support. Evaluating $By$ at requested targets does not certify it vanishes elsewhere. The cost of producing complete support for either schedule input, a full array of outputs, and a multiplication supplier are separate questions.
39 changes: 39 additions & 0 deletions research/clifford-transported-fibre-gram/README.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,39 @@
# Query any Clifford fibre and apply the width-13 Gram operator

For the four-qubit width-13 dictionary, a change of Pauli coordinates turns the full Gram matrix into **256 independent copies of one scalar convolution** on $\operatorname{Sp}(8,2)$. Given coefficient blocks on known source fibres, the program evaluates any requested target blocks of the Gram, its exact inverse, or either complete #7809 schedule. A second consumer evaluates the specified Bell inverse on arbitrary affine-quadratic observations. Every requested symplectic target shares one partial Walsh transform, including queries outside the Clifford column span. [Proof, absolute lifts and resource bounds](PROOF.md)

| Supplied input | Requested quantity | Work shared across queries |
|---|---|---|
| One 104-bit affine-quadratic chart | All 256 Bell decoder coefficients in each named fibre | One Gauss sum in at most 48 variables and one singleton basis. At most 4,265 signed bin updates per target. |
| Coefficients on $m$ complete source blocks, $r$ target blocks | $Kc$ or $K^{-1}c$ | Synthesize each source matrix once. At most $mr$ binary ranks or relative class lookups, and $256mr$ real-weight/complex-entry multiply-adds. |
| Starting coefficients $d_0$ and adjoint values $t$ on supplied supports | The final $d$ of either 51 or 52 updates $d\gets d+h(t-Kd)$ | Two scalar kernels compiled on 80 rational classes; the query cost depends on source and target counts and coefficient sizes. |

Here each omitted source fibre has zero coefficients. General observations can have dense $A^*y$ and $By$; preparing their complete supports has a separate cost. For a known mixture $y=Ac$, the first normal-operator query gives $A^*y$ directly. The minimum common denominators for the compiled inverse Gram, 51-step pair and 52-step pair have bit lengths 145, 11,381 and 7,500, respectively. This contribution concerns decoder arithmetic at the existing width and multiplication bound. [Class recognition and reproducible GAP table](CLASS-ALGEBRA.md) · [Independent spectrum](https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/RESULT.json)

Ali Romman's #7815 recovers *unknown* support from a supplied exact tensor train, including any 19 four-qubit terms at width 13. Its complete output can supply the mixture above after rephasing the reported columns. Read its signature as $W_{\mathrm{output},\mathrm{input}}$, with signature index $16\,\mathrm{input}+\mathrm{output}$. Identify $S$ by conjugating the eight basis Weyls. If its normalized unitary $W/(1+i)^h=\eta W_pU_S$, multiply its coefficient by $\eta^{13}$ to express it in this package's convention. The 256 trace coordinates of `extract` identify $p$ and $\eta$. [Tensor-train decoder and signature format](https://github.com/aliromman/integer-mult-bounds/blob/34a20a30596467409e7361534d52495819787a78/research/clifford-unknown-support-decoder/README.md)

## Reproduce

Use CPython 3.12 and its standard library from the repository root.

```sh
python3.12 -B scripts/research_package.py --package research/clifford-transported-fibre-gram
```

`readout.py input.json` accepts the #5704 `circuit`, optional `initial` address and `targets`. A target is the array of eight column images in the four-qubit binary Pauli convention. The output order is $16x+z$ with Gaussian rational pairs. The two independent readout oracles check every transported record at four targets, complex phases on literal tensor columns, and arbitrary nonmember observations. [Readout](readout.py) · [Oracle](verify_readout.py)

`gram.py input.json` accepts the actions `gram`, `canonical`, `schedule51`, and `schedule52`. The first two take one list of source blocks. The schedules take two lists giving $d_0$ and $t$, respectively. Within each block, omitted Pauli indices are zero. Exact rational strings are accepted. For example, this request applies $K$ to the identity coefficient and asks for the fibre of a single X-axis transvection. The Pauli-identity output is $(-1+i)/128$.

```json
{"action":"gram","inputs":[[{"target":[1,2,4,8,16,32,64,128],"coefficients":{"0":["1","0"]}}]],"targets":[[17,2,4,8,16,32,64,128]]}
```

The ordinary/optimized checks regenerate the filters, compare actual scheduled convolution factors in the class basis, and test literal thirteenth powers of complex traces, including zeros and nonzero odd-dimensional fixed spaces. [Gram consumer](gram.py) · [Independent checks](verify_gram.py) · [Verifier manifest](VERIFY.json)

## Open next questions

Which observation producers admit a direct compact description of $A^*y$ on a few fibres, or of its sum against the compiled scalar kernels, even when $y$ lies outside the Clifford span? An end-to-end estimate would include producing those values, moving them to this interface and delivering the requested outputs.

## Credit

The affine-quadratic signature and Gaussian contraction machinery are due to Ali Romman, with their retained notices. Nick Petalas and Ali Romman provided the fixed-space character calculations and spectral blocks, building on alephnan's Clifford sector work. The Bell compiler, compact identity-fibre consumer and scalar schedules are earlier work by apoursh. The native class construction uses the GAP Group's software. This extension and verification were prepared by apoursh with substantial OpenAI Codex assistance, under Apache-2.0. [Source pins](SOURCE-PINS.json) · [Retained notices](retained/predecessor/source/engine/source/) · [Public collaboration claim](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19756386)
Loading
Loading