diff --git a/research/clifford-dyadic-left-inverse/PROOF.md b/research/clifford-dyadic-left-inverse/PROOF.md new file mode 100644 index 0000000000..f0b839e30a --- /dev/null +++ b/research/clifford-dyadic-left-inverse/PROOF.md @@ -0,0 +1,329 @@ +# A Gaussian-dyadic left inverse for the Clifford tensor alphabet + +This is an algebraic construction of a left inverse. It gives an explicit +coefficient-ring guarantee at a sufficient tensor width, without constructing +the enormous matrix or pricing a physical decoder. No new kappa is claimed. + +## 1. Statement and boundary + +Put `R = Z[i,1/2]`, fix `n >= 1`, and set `d = 2^n`. Let `G` be the +Gaussian-dyadic unitary Clifford group on `n` qubits, and choose one matrix +`U_a` in every scalar coset of `G / `. The scalar convention and signed +Hermitian Pauli action are those of +[alephnan's Clifford framework](https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md). +Write `N = |G / |`. Define the raw tensor-column matrix + +```text +C_f[:,a] = vec(U_a^(tensor f)). +f_0 = 4 n 2^n = 4nd. +``` + +**Theorem.** For every integer `f >= f_0`, there is an explicitly specified +matrix `L_f` with entries in `R` such that + +```text +L_f C_f = I_N. +``` + +The specification consists of determinant, trace and polynomial coefficient +operations on the chosen representatives. It introduces no division by odd +integers. In particular, the columns generate a direct summand of the free +`R`-module of observations. The sufficient width is not asserted to be minimal. + +For the full four-qubit alphabet, `d=16`, `N=12,128,668,876,800`, and +`f_0=256`. The normalized map used in +[Ali Romman's odd-width spectral proof](https://github.com/aliromman/integer-mult-bounds/blob/9a8ce06644700ffa576d99316450bcb52835d6dc/research/clifford-odd-width-spectrum/PROOF.md) +is + +```text +A_f[:,a] = vec(U_a^(tensor f)) / 16^(f/2) + = vec(U_a^(tensor f)) / 2^(2f). +``` + +Thus `B_f = 2^(2f) L_f` has entries in `R` and satisfies `B_f A_f=I_N` +for every integer `f >= 256`, including every residue class modulo four. +For general `n`, the same normalized conclusion follows whenever `nf` is +even. The raw theorem above does not need that restriction. + +This answers the existence part of +[PR #7792's arbitrary-left-inverse question](https://github.com/aliromman/integer-mult-bounds/blob/9321c67e29c3c41a188154bc5c2add7d7802b694/research/clifford-odd-division-obstruction/PROOF.md) +at an explicit larger width. In particular, at `f=257` that source proves +that the canonical least-squares map has a necessary odd denominator, while +the present map has none. Existence at widths `13 <= f < 256`, the least +width for such a split injection, and an efficient or stable realization +are not settled here. + +## 2. Elementary ring and Pauli facts + +### Gaussian-dyadic numbers of modulus one + +If `z=(a+bi)/2^k` belongs to `R` and has modulus one, then +`a^2+b^2=2^(2k)`, for integers `a,b` and `k >= 0`. For `k>0`, squares +modulo four show that both `a` and `b` are even. Divide them by two and +decrease `k` by one. Repetition reaches `a^2+b^2=1`, so + +```text +z in {1, i, -1, -i}, and z^4 = 1. +``` + +If `U` is any unitary matrix over `R`, its determinant `Delta(U)` lies in +`R` and has modulus one. Therefore `Delta(U)^4=1`. This fact needs neither +a generating set for the Clifford group nor a determinant-one convention. + +### Signed generator images distinguish scalar cosets + +Use the `2n` Hermitian Pauli generators + +```text +P_1,...,P_(2n) = X_1,Z_1,...,X_n,Z_n. +``` + +They square to the identity and have entries in `R`. Clifford conjugation +sends each one to a signed Hermitian Pauli. For any two signed Hermitian +Paulis `Q,Q'` that are not scalar identities, their normalized pairing is + +```text +Tr(Q Q')/d = 1 if Q'=Q, + -1 if Q'=-Q, + 0 otherwise. +``` + +This follows from the ordinary Pauli orthogonality relation; the Pauli +matrices form an orthogonal basis for all `d`-by-`d` complex matrices. + +If `U_a` and `U_b` have the same signed conjugation image on every `P_j`, +then `U_a^* U_b` commutes with all `P_j`. Commutation with the `Z_j` +makes this matrix diagonal, and commutation with the `X_j` makes all its +diagonal entries equal. Hence `U_a^* U_b = zI`. It is unitary over `R`, +so the preceding ring fact gives `z in `. Consequently the two chosen +representatives have the same coset. This proves that agreement on all +`2n` signed images is equivalent to `a=b`. + +## 3. Homogeneous interpolation without odd division + +Let `X=(x_uv)` be a matrix of independent commuting indeterminates over +`R`. Write + +```text +Delta(X) = det(X), +Q_(a,j) = U_a P_j U_a^*, +t_(a,j)(X) = Tr(Q_(a,j) X P_j adj(X)) / d. +``` + +The adjugate is its usual cofactor polynomial, defined even when `X` is +singular. `Delta` is homogeneous of degree `d`; every entry of `adj(X)` +is homogeneous of degree `d-1`; therefore `t_(a,j)` is homogeneous of +degree `d`. All coefficients lie in `R`, because `1/d=2^(-n)` is a +dyadic unit. No inverse of a variable matrix is used in this definition. + +At an alphabet point `U_b`, unitarity gives +`adj(U_b)=Delta(U_b) U_b^*`. Hence + +```text +t_(a,j)(U_b) = Delta(U_b) u_(a,b,j), +u_(a,b,j) = Tr(Q_(a,j) Q_(b,j))/d in {-1,0,1}. +``` + +Now define the homogeneous polynomial of degree `2d` + +```text +h_(a,j)(X) = (t_(a,j)(X)^2 + t_(a,j)(X) Delta(X)) / 2. +``` + +For `u in {-1,0,1}`, the value `(u^2+u)/2` is one exactly when `u=1`, +and zero otherwise. Thus + +```text +h_(a,j)(U_b) = Delta(U_b)^2 * 1[Q_(a,j)=Q_(b,j)]. +``` + +An individual factor need not itself be the indicator: its determinant +factor can be minus one. Retaining that phase is essential. Define + +```text +F_a(X) = product_(j=1)^(2n) h_(a,j)(X). +``` + +This has coefficients in `R` and degree `4nd`. At every `U_b`, the +determinant phases cancel because +`(Delta(U_b)^2)^(2n)=Delta(U_b)^(4n)=1`. Section 2 then proves + +```text +F_a(U_b) = product_j 1[Q_(a,j)=Q_(b,j)] = delta_(a,b). +``` + +Only powers of two have been divided out. In particular, a difference of +two spectral eigenvalues or two trace values is never inverted. That is +why odd factors in the canonical Gram inverse do not obstruct this +construction. + +### Padding to every larger width + +For each fixed representative define the degree-one polynomial + +```text +ell_a(X) = Tr(U_a^* X)/d, +ell_a(U_a) = 1. +``` + +For `f >= f_0`, put + +```text +F_(a,f)(X) = F_a(X) ell_a(X)^(f-f_0). +``` + +It is homogeneous of degree `f` over `R`, and +`F_(a,f)(U_b)=delta_(a,b)`. If `a!=b`, the first factor already vanishes; +if `a=b`, the padding factor equals one. The exponent can be zero. + +## 4. From a polynomial to a linear tensor functional + +The distinction between a polynomial in a matrix and a linear map on +tensor observations matters. A homogeneous degree-`f` polynomial is a +linear functional on the `f`-fold tensor coordinates, once an ordering +convention is fixed. Here that lift can be made without symmetrization +or factorial denominators. + +List the `d^2` coordinates of `X` in a fixed order. Expand + +```text +F_(a,f)(X) = sum_(alpha: sum alpha=f) c_(a,alpha) x^alpha. +``` + +For each multi-index `alpha`, choose the one ordered tensor word that +lists coordinate 1 `alpha_1` times, then coordinate 2 `alpha_2` times, +and so on. Give that word coefficient `c_(a,alpha)` and every other +word for the same commutative monomial coefficient zero. On +`vec(X)^(tensor f)` the resulting functional evaluates exactly +`F_(a,f)(X)`. The entries of `vec(X^(tensor f))` are a fixed permutation +of these same ordered products, so permuting the functional gives a +row indexed by the observations in `C_f`. + +Stack the rows for all `a` to obtain `L_f`. Its entries are the +coefficients above or zero, hence lie in `R`. The interpolation identity +in Section 3 proves, entry by entry, + +```text +(L_f C_f)[a,b] = F_(a,f)(U_b) = delta_(a,b). +``` + +No multinomial coefficient is divided out. This is a finite algebraic +specification for every fixed `n,f`; its possibly enormous number of +terms is not a polynomial-time or physical-resource bound. + +The direct-summand conclusion also follows explicitly. `C_f L_f` is an +idempotent on the observation module, with image `im(C_f)` and kernel +`ker(L_f)`. Every observation `y` has the unique decomposition + +```text +y = C_f L_f y + (y - C_f L_f y), +R^(d^(2f)) = im(C_f) direct_sum ker(L_f). +``` + +In particular, if a nonzero `r in R` and `ry` lies in `im(C_f)`, then +`r(y-C_f L_f y)=0` in a free module over the integral domain `R`. +Thus `y=C_f L_f y` also lies in the image: the column module is +saturated. No separate saturation assumption is required. + +## 5. Recovery contract and relation to the canonical obstruction + +For four qubits the normalized conclusion is + +```text +B_f A_f = I_N, f >= 256, +B_f in Mat_(N,d^(2f))(R). +``` + +It implies `B_f(A_f c)=c` for every complex coefficient vector `c`, +and in particular for every coefficient vector over `R`. The map `B_f` +is linear and defined on the entire observation space. For arbitrary +observations of the form `y=A_f c+e`, its output is + +```text +B_f y = c + B_f e. +``` + +There is no claim here that `B_f e` is small, or that `B_f` minimizes a +norm or least-squares residual. On the image of `A_f`, every left inverse +agrees with exact recovery. Outside that image, different left inverses +may differ. + +At width `257`, the canonical map +`A_f^+ = (A_f^* A_f)^(-1) A_f^*` exists and, by the scoped theorem in +PR #7792, does not have all coefficients in `R`. Since `B_257` does, +these are distinct maps. This is a positive realization of the +left-inverse distinction in that source; it does not contradict its +canonical-map obstruction. The spectral identification in PR #7792 is +needed for this comparison, but not for the interpolation theorem. + +The result supplies no precision allocation, bounded recovery norm, +native preparation, routing, clean-stock funding, owned-state restoration +or full caller invoice. A finite algebraic matrix is not a physical +supplier. The selected exponent, five framework assumptions and existing +source packages remain unchanged. + +## 6. Why the Clifford hypothesis cannot be dropped + +Take `n=3`, let the target representative be the identity, and consider +the unitary Gaussian-dyadic matrix + +```text +W = CCZ = diag(1,1,1,1,1,1,1,-1). +``` + +This is not a Clifford matrix. It commutes with every `Z_j`, so the +three corresponding normalized pairings `u_j` are one. For `X_j`, +conjugation changes the sign on exactly the two basis states whose +other two bits are one. Thus + +```text +Tr(X_j W X_j W^*)/8 = (6-2)/8 = 1/2. +``` + +Its determinant is minus one, so the total determinant factor still +cancels. Nevertheless the proposed identity-target interpolant gives + +```text +F_I(W) = (( (1/2)^2 + 1/2 )/2)^3 = (3/8)^3 = 27/512. +``` + +This is neither zero nor one. The indicator argument requires the +discrete pairings `{-1,0,1}` furnished by signed Pauli normalization; +unitarity and Gaussian-dyadic entries alone are insufficient. + +The scalar convention matters as well. At width 256, `U` and `iU` have +identical tensor columns, so no left inverse can distinguish all exact +scalar lifts as separate columns. The theorem concerns one representative +per scalar coset, exactly as in the retained spectral contract. + +## 7. Evidence, credit and next questions + +The all-`n` and all-sufficient-width statements follow from Sections 2--4. +Finite evaluations check implementations and failure controls; they do +not replace this proof. In particular, no full four-qubit matrix or +left inverse is materialized, and no independent human or proof-kernel +acceptance is claimed. + +Ali Romman supplied the canonical odd-division obstruction and the +four-qubit tensor normalization and spectral context. Nick Petalas +supplied retained character projections and related exact denominator +work. alephnan supplied the Gaussian-dyadic scalar and Pauli-sector +framework used above; its own source retains the pointwise-faithfulness, +MatShep and earlier Clifford lineage. Those sources retain their credit +and licenses. Adjugates, Pauli orthogonality, polynomial interpolation, +tensor coefficient lifts and direct-summand arguments are classical. +This contribution is the explicit dyadic interpolant and its application +to the different-left-inverse question. Prepared by **apoursh**, with +substantial OpenAI Codex and separate agent assistance. Apache-2.0. + +The smallest useful next question is whether a Gaussian-dyadic left +inverse already exists near the known four-qubit complex independence +threshold, starting at width 13. A minor-ideal or modular rank obstruction +would distinguish failure of a split injection from mere failure of a +canonical inverse. The present construction gives the finite upper bound +256, without deciding the intermediate widths. + +A separate implementation question is to bound the norm and realizable +cost of a specified left inverse at a specified caller. The sparse +polynomial specification alone does not supply such a bound or a +favorable complete signed bill. diff --git a/research/clifford-dyadic-left-inverse/README.md b/research/clifford-dyadic-left-inverse/README.md new file mode 100644 index 0000000000..854523adfc --- /dev/null +++ b/research/clifford-dyadic-left-inverse/README.md @@ -0,0 +1,146 @@ +# Exact Gaussian-dyadic Clifford recovery at sufficient tensor width + +**Algebraic construction; no new κ.** For the full four-qubit projective +Clifford alphabet, every integer tensor width `f >= 256` admits a left inverse +whose coefficients all lie in `R = Z[i,1/2]`. This answers the noncanonical +left-inverse question in [PR #7792](https://github.com/CrocSwap/integer-mult-bounds/pull/7792) +at an explicit sufficient width. It does not determine the least width or +supply an affordable physical decoder. + +The [proof](PROOF.md) establishes the stronger raw-tensor statement for every +`n >= 1`: width `f >= 4n2^n` suffices. For four qubits, the source map is + +```text +A_f[:,a] = vec(U_a^(tensor f)) / 2^(2f), +B_f A_f = I, B_f has entries in Z[i,1/2]. +``` + +There is one column for each scalar coset modulo ``, with arbitrary fixed +representatives. The columns generate a direct summand, hence a saturated +module, over R. At `f=257`, the canonical least-squares map requires odd +division by #7792, while this different exact left inverse does not. The +canonical result and this construction are compatible. + +## Construction + +Let `d=2^n`, let `P_j` run through the `2n` Hermitian generators `X_j,Z_j`, +and put `Q_(a,j)=U_a P_j U_a*`. For a variable matrix X define + +```text +Delta(X) = det X, +t_(a,j)(X) = Tr(Q_(a,j) X P_j adj(X)) / d, +h_(a,j)(X) = (t_(a,j)(X)^2 + t_(a,j)(X) Delta(X)) / 2, +F_a(X) = product_(j=1)^(2n) h_(a,j)(X). +``` + +Each factor evaluates to `Delta(U_b)^2` times the indicator that the two +signed Pauli images agree. The determinant lies in `{1,i,-1,-i}`, so the +phase cancels across `2n` factors. Agreement on all generators identifies a +scalar coset. Thus `F_a(U_b)=delta_ab`, with homogeneous degree `4nd` and +only dyadic denominators. Multiplying by +`(Tr(U_a*X)/d)^(f-4nd)` pads to every larger width. + +A coefficient of each commutative monomial is assigned to one ordered tensor +word. This makes the polynomial a linear tensor functional without dividing +by factorials or multinomial coefficients. The full matrix is specified +algebraically, not materialized. + +## Verification + +Use CPython 3.12 and the standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/clifford-dyadic-left-inverse +``` + +`VERIFY.json` registers normal and optimized runs of both implementations. +All four runs pass on CPython 3.12.14 (macOS arm64). +They use exact rational Gaussian arithmetic and explicit checks that remain +active under `-O`. The written proof supplies the infinite quantifiers. + +- `verify.py` expands commutative one-qubit polynomials, chooses sorted tensor + words, and checks the normalized left-inverse identity. It also checks + literal four-qubit matrix examples and authenticates the retained sources. + Coverage: 1,392 commutative polynomial coefficients, all 576 one-qubit + left-inverse entries, 256 literal tensor coordinates, 16 four-qubit matrices, + 128 generator images, 2,048 pairings and 256 interpolation entries. Six + faulty variants and three mutated source files are rejected. +- `independent_check.py` imports no primary or predecessor implementation. + It enumerates operators by their entries and expands noncommutative ordered + coordinate words. Its complete one-qubit calibration has 96 matrices, 24 + projective cosets, 2,304 interpolation pairs, 6,912 phase-padding cases, + 576 normalized left-inverse entries, 12,288 row terms and 1,536 tensor + coordinates. Five faulty variants are rejected. +- Phase controls include 48 matched lifts for which both individual detector + factors are minus one. Omitting the determinant or the signed term changes + the map. The non-Clifford CCZ example gives `27/512`, showing why unitarity + and dyadic entries alone are insufficient. + +These are finite implementation checks, not a full four-qubit enumeration or +formal-kernel proof. No character table, predecessor executable, Lean, Docker, +selected scientific cold replay or complete multiplication program is run. +The selected source-binding orientation passed separately. + +## Sources, overlap and attribution + +Canonical main was pulled on 2026-11-19 at +`e54523517d0f03e58352e647c403a5af3e525a57`. Priority revision 8 is older than +the selected #7000 record; the task is explicitly a changed-scope algebraic +side result of `uniform-transfer-audit`, not discharge of a selected caller +assumption. [TASK.json](TASK.json) retains the original card and the bounded +family decision. + +[SOURCE-PINS.json](SOURCE-PINS.json) records exact commits, original Git blob +IDs, SHA-256 hashes, URLs and byte lengths for three unmodified proof files: + +- Ali Romman's #7792 canonical obstruction at + `9321c67e29c3c41a188154bc5c2add7d7802b694` supplies the open question and + the canonical comparison. +- Ali Romman's #7788 at `9a8ce06644700ffa576d99316450bcb52835d6dc` + supplies the four-qubit tensor normalization and alphabet size. +- alephnan's #6714 at `f7f32a18dde54e67624a9ed9cc7e1b266d9585c0` + supplies the Gaussian-dyadic scalar and Pauli framework. + +Their proof bytes are retained inside this package so an exported replay +needs neither network access nor unmerged Git objects. `SOURCES.json` binds +the base catalogue and selected record as historical provenance; the +separate source manifest binds these package-local retained proofs. The new +interpolation proof is elementary and independent of the character-table +computations; only its comparison with the canonical inverse uses their +reported spectral theorem. + +Fresh all-state PR searches and the newest direct PR-body corpus found no +matching positive construction. The repository overlap helper could not +fetch remote corpora because `gh` was unavailable. Discussion snapshots and +sparse local notes are incomplete; this is not a global novelty guarantee. +Newer cubic work #7506/#7543 was checked before choosing a different family. +The scoped [claim](https://github.com/CrocSwap/integer-mult-bounds/pull/7792#issuecomment-7012504080) +records this investigation on its source question. No predecessor package or +shared implementation is changed. + +Prepared by **apoursh**, with substantial **OpenAI Codex and separate agent +assistance** in proof, implementation and review. Credit Ali Romman, +Nick Petalas, alephnan and their retained predecessor lineage. Classical +adjugate, Pauli orthogonality, interpolation, tensor lifting and module +arguments are not claimed as new. Source notices remain intact. Apache-2.0. +No independent human acceptance or proof-kernel verification is claimed. + +## Limits + +A left inverse is exact on the image: `B_f(A_f c)=c` for every coefficient +vector. On arbitrary noisy observations its error is `B_f e`; no useful +norm or stability bound is supplied. Precision, movement, storage, native +preparation, owned-state restoration and the complete caller bill remain +unknown. No new supplier, physical speedup or κ follows. + +## Open next questions + +1. Determine the smallest width that admits an R-left inverse. Start with + the actual module or modular ranks at widths near the complex independence + threshold 13. The canonical Gram denominators alone cannot decide this; + widths 13 through 255 remain unresolved by this contribution. +2. For a specified caller, bound and price a chosen noncanonical decoder. + First derive its recovery norm and a complete evaluation/restoration bill. + Algebraic existence is insufficient justification for a large implementation. + +The structured questions and blockers are also in `TASK.json`. diff --git a/research/clifford-dyadic-left-inverse/SOURCE-PINS.json b/research/clifford-dyadic-left-inverse/SOURCE-PINS.json new file mode 100644 index 0000000000..e8e8f003e5 --- /dev/null +++ b/research/clifford-dyadic-left-inverse/SOURCE-PINS.json @@ -0,0 +1,35 @@ +{ + "scope": "Exact self-contained retained proof bytes from pending public heads; no source code or character table is executed. Original Git objects are not required by the replay.", + "files": [ + { + "path": "sources/canonical-obstruction.md", + "repository": "aliromman/integer-mult-bounds", + "commit": "9321c67e29c3c41a188154bc5c2add7d7802b694", + "original_path": "research/clifford-odd-division-obstruction/PROOF.md", + "url": "https://github.com/aliromman/integer-mult-bounds/blob/9321c67e29c3c41a188154bc5c2add7d7802b694/research/clifford-odd-division-obstruction/PROOF.md", + "sha256": "ab8551bbf4da59db361b00fc9dbd78ccc8327b1f943871a8094bba3861bb64dc", + "git_blob": "ca5067396e6a3d7a9be6aa4c1552ac655fced964", + "bytes": 8260 + }, + { + "path": "sources/four-qubit-map.md", + "repository": "aliromman/integer-mult-bounds", + "commit": "9a8ce06644700ffa576d99316450bcb52835d6dc", + "original_path": "research/clifford-odd-width-spectrum/PROOF.md", + "url": "https://github.com/aliromman/integer-mult-bounds/blob/9a8ce06644700ffa576d99316450bcb52835d6dc/research/clifford-odd-width-spectrum/PROOF.md", + "sha256": "a9ed8df52b2a090dfc1533be551ce3a68af030163ebedbbdad9104ff6c1d6f1e", + "git_blob": "75c4dd2844c67b694cfb699eae56f82a70a3c43d", + "bytes": 10849 + }, + { + "path": "sources/clifford-ring.md", + "repository": "alephnan/integer-mult-bounds", + "commit": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0", + "original_path": "research/clifford-three-qubit-threshold/PROOF.md", + "url": "https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md", + "sha256": "d29091eb12b4ccd3f5acb389634a858af3beb0dc78865613bb7bd68c9440c6d0", + "git_blob": "9f89ee36a0a1a0bdda09582d88477e15674fda5e", + "bytes": 17137 + } + ] +} diff --git a/research/clifford-dyadic-left-inverse/SOURCES.json b/research/clifford-dyadic-left-inverse/SOURCES.json new file mode 100644 index 0000000000..5335fa97d9 --- /dev/null +++ b/research/clifford-dyadic-left-inverse/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + ] +} diff --git a/research/clifford-dyadic-left-inverse/TASK.json b/research/clifford-dyadic-left-inverse/TASK.json new file mode 100644 index 0000000000..f0a9e2f8ae --- /dev/null +++ b/research/clifford-dyadic-left-inverse/TASK.json @@ -0,0 +1,138 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "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" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Construct a Gaussian-dyadic left inverse of the full projective four-qubit Clifford tensor map at every integer width f>=256, answering the noncanonical recovery question in PR7792. The concrete object is the column module over Z[i,1/2]; no selected supplier assumption is claimed discharged.", + "scope_change_reason": "The assigned audit track is narrowed to a new source-specific algebraic feasibility result rather than a selected caller or physical decoder. The boundary changes from the canonical inverse on arbitrary observations to a different linear inverse that is exact on the tensor-map image.", + "bottleneck_link": "Enabling side result: distinguishes an odd-denominator obstruction for the canonical decoder from the existence of any Gaussian-dyadic exact recovery map. Movement, stock, precision, conditioning and the complete caller invoice remain unknown.", + "budget_minutes": 60, + "stop_rule": "Stop at one proved explicit width bound, an independently checked polynomial-to-tensor construction, source bindings and failure controls. Do not optimize the bound or claim a physical supplier.", + "outcome": "completed", + "evidence": "PROOF.md: all n and all f>=4n2^n raw tensor theorem, normalized four-qubit f>=256. verify.py: exact commutative polynomial lift, literal matrices, six rejection and three source mutation controls. independent_check.py: separate entry enumeration and ordered-word lift with five rejection controls. Registered normal and optimized runs; publication integrity and exported replay recorded in the PR.", + "author": "apoursh", + "ai_assistance": "Substantial OpenAI Codex assistance with separate source/overlap and mathematical audit agents; no independent human or formal-kernel acceptance claimed.", + "open_questions": [ + { + "question": "What is the least width admitting a Gaussian-dyadic left inverse of the full four-qubit alphabet?", + "why_it_matters": "The construction gives an upper bound only; the source complex rank threshold is 13.", + "first_step": "Test reductions of the actual tensor map at selected odd primes for one width below 256, using Pauli/quotient structure rather than a full matrix.", + "blocked_by": "The canonical Gram spectrum does not decide saturation of the column module." + }, + { + "question": "Can this exact noncanonical decoder be realized with acceptable conditioning and complete physical cost at a specified caller?", + "why_it_matters": "Algebraic recovery alone does not supply an affordable recursive decoder.", + "first_step": "Choose one caller and derive the norm and complete coefficient-evaluation, movement, storage and restoration invoice before implementation expansion.", + "blocked_by": "No priced physical realization or useful norm bound is supplied." + } + ], + "scope_key": "58d0403e3078b2c5ae8a", + "source_heads": { + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "PR7792": "9321c67e29c3c41a188154bc5c2add7d7802b694", + "PR7788": "9a8ce06644700ffa576d99316450bcb52835d6dc", + "PR6714": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0" + }, + "family_decision": { + "decision": "narrow", + "comparison": "Canonical spectral inversion provably needs odd division at covered widths. Pauli-generator interpolation changes the decoder while preserving exact noise-free recovery. Cubic local-obstruction extensions are not pursued.", + "cost_ledger": { + "coefficient_ring": "proved in the proposed construction", + "finite_linear_map": "constructive symbolic polynomial coefficient rule", + "physical_costs": "unknown", + "conditioning": "unknown" + }, + "reopen": "A lower tensor width or a source-specific complete implementation and caller bill is a separate decision." + }, + "overlap": { + "checked_at_utc": "2026-11-19T14:39:48Z", + "source_pr": 7792, + "nearest_heads": { + "canonical_main": "e54523517d0f03e58352e647c403a5af3e525a57", + "PR7792": "9321c67e29c3c41a188154bc5c2add7d7802b694", + "PR7788": "9a8ce06644700ffa576d99316450bcb52835d6dc", + "PR6714": "f7f32a18dde54e67624a9ed9cc7e1b266d9585c0" + }, + "all_state_queries": [ + "Clifford left inverse", + "Clifford interpolation", + "Clifford Pauli interpolation", + "dyadic decoder" + ], + "latest_direct_body_corpus": "25 most recently updated open PRs, through PR7796", + "finding": "No observed matching positive construction; indexed searches are not novelty certificates.", + "coverage_limits": [ + "Dedicated source-overlap helper has no remote corpus because gh is absent.", + "Discussion sort-new snapshot is incomplete/stale; sparse local notes omit many packages." + ], + "claim_posting": "Published as apoursh at https://github.com/CrocSwap/integer-mult-bounds/pull/7792#issuecomment-7012504080; expiry 2026-11-19T16:50:00Z; publication update belongs to that canonical comment." + }, + "upstream_refresh": { + "entry": "2026-11-19", + "before_publication": "2026-11-19", + "commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "status": "unchanged", + "selected_orientation": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "catalog_context": "Revision8 refers to5599; selectedrecordis7000. Historicalcardpreserved; nofrontierchange." + } +} diff --git a/research/clifford-dyadic-left-inverse/VERIFY.json b/research/clifford-dyadic-left-inverse/VERIFY.json new file mode 100644 index 0000000000..3bd13add84 --- /dev/null +++ b/research/clifford-dyadic-left-inverse/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": 180, + "checks": "Primary exact commutative-polynomial lift, source pins and four-qubit examples" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Primary exact commutative-polynomial lift, source pins and four-qubit examples under optimized Python" + }, + { + "argv": [ + "{python}", + "-I", + "-W", + "error", + "-B", + "{package}/independent_check.py" + ], + "timeout_seconds": 180, + "checks": "Independent entry-enumerated Clifford matrices, ordered tensor rows, phase padding and controls" + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-W", + "error", + "-B", + "{package}/independent_check.py" + ], + "timeout_seconds": 180, + "checks": "Independent entry-enumerated Clifford matrices, ordered tensor rows, phase padding and controls under optimized Python" + } + ] +} diff --git a/research/clifford-dyadic-left-inverse/independent_check.py b/research/clifford-dyadic-left-inverse/independent_check.py new file mode 100644 index 0000000000..ea0ba3a1ab --- /dev/null +++ b/research/clifford-dyadic-left-inverse/independent_check.py @@ -0,0 +1,297 @@ +#!/usr/bin/env python3 +"""Independent finite calibration of the Clifford interpolation construction. + +Enumerates one-qubit operators by their entries, not by generator closure. +Expands ordered coordinate words, not commutative polynomial monomials. +No primary checker or predecessor implementation is imported. These finite +checks corroborate PROOF.md; they do not enumerate the four-qubit alphabet. + +apoursh, with substantial OpenAI Codex assistance. Apache-2.0. +""" + +from fractions import Fraction as F +from itertools import product +import json + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def g(real=0, imag=0): + return (F(real), F(imag)) + + +ZERO, ONE, I = g(), g(1), g(0, 1) +UNITS = (ONE, I, g(-1), g(0, -1)) + + +def add(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def neg(a): + return (-a[0], -a[1]) + + +def mul(a, b): + return (a[0] * b[0] - a[1] * b[1], + a[0] * b[1] + a[1] * b[0]) + + +def conj(a): + return (a[0], -a[1]) + + +def times(a, scalar): + return (a[0] * scalar, a[1] * scalar) + + +def total(values): + result = ZERO + for value in values: + result = add(result, value) + return result + + +def power(a, exponent): + result = ONE + for _ in range(exponent): + result = mul(result, a) + return result + + +def mm(a, b): + return tuple(total(mul(a[2 * r + k], b[2 * k + c]) + for k in range(2)) + for r in range(2) for c in range(2)) + + +def star(a): + return (conj(a[0]), conj(a[2]), conj(a[1]), conj(a[3])) + + +def mscale(a, scalar): + return tuple(mul(scalar, x) for x in a) + + +def det(a): + return add(mul(a[0], a[3]), neg(mul(a[1], a[2]))) + + +def adj(a): + return (a[3], neg(a[1]), neg(a[2]), a[0]) + + +def tr(a): + return add(a[0], a[3]) + + +ID = (ONE, ZERO, ZERO, ONE) +X = (ZERO, ONE, ONE, ZERO) +Y = (ZERO, neg(I), I, ZERO) +Z = (ONE, ZERO, ZERO, g(-1)) +PAULIS = (X, Y, Z) + tuple(mscale(a, g(-1)) for a in (X, Y, Z)) + + +def canonical(a): + return min(mscale(a, phase) for phase in UNITS) + + +def operators(): + """Enumerate all axis/flat one-qubit entries; verify all Pauli images.""" + alphabet = (ZERO,) + UNITS + tuple(g(F(a, 2), F(b, 2)) + for a in (-1, 1) for b in (-1, 1)) + columns = [c for c in product(alphabet, repeat=2) + if total(mul(conj(z), z) for z in c) == ONE] + raw = [] + for left, right in product(columns, repeat=2): + if total(mul(conj(a), b) for a, b in zip(left, right)) != ZERO: + continue + a = (left[0], right[0], left[1], right[1]) + require(mm(star(a), a) == ID, "entry enumeration lost unitarity") + require(det(a) in UNITS, "determinant is not a Gaussian unit") + require(all(mm(mm(a, p), star(a)) in PAULIS for p in (X, Y, Z)), + "enumerated operator does not normalize Paulis") + raw.append(a) + require(len(raw) == len(set(raw)) == 96, "wrong entry enumeration") + reps = sorted(set(canonical(a) for a in raw)) + require(len(reps) == 24, "wrong projective alphabet size") + images = {(mm(mm(a, X), star(a)), mm(mm(a, Z), star(a))) for a in reps} + require(len(images) == 24, "Pauli images do not distinguish cosets") + # There are precisely 6*4 ordered anticommuting signed axes. + all_images = {(p, q) for p in PAULIS for q in PAULIS + if mm(p, q) == mscale(mm(q, p), g(-1))} + require(images == all_images, "one-qubit calibration is not complete") + return raw, reps + + +def scalar_detector(target, value, mode="correct"): + determinant = det(value) + answer = ONE + for p in ((X,) if mode == "omit_generator" else (X, Z)): + q = mm(mm(target, p), star(target)) + t = times(tr(mm(mm(mm(q, value), p), adj(value))), F(1, 2)) + if mode == "unsigned": + term = mul(t, t) + elif mode == "omit_determinant": + term = times(add(mul(t, t), t), F(1, 2)) + else: + term = times(add(mul(t, t), mul(t, determinant)), F(1, 2)) + answer = mul(answer, term) + return answer + + +def merge_term(poly, word, value): + value = add(poly.get(word, ZERO), value) + if value == ZERO: + poly.pop(word, None) + else: + poly[word] = value + + +def word_add(a, b): + result = dict(a) + for word, value in b.items(): + merge_term(result, word, value) + return result + + +def word_times(a, scalar): + return {w: times(z, scalar) for w, z in a.items() if z != ZERO} + + +def word_mul(a, b): + result = {} + for wa, ca in a.items(): + for wb, cb in b.items(): + merge_term(result, wa + wb, mul(ca, cb)) + return result + + +def ordered_row(target): + """Expand straight-line products by concatenation; never symmetrize.""" + determinant = {(0, 3): ONE, (1, 2): g(-1)} + # adj(X)_(l,i) is a signed coordinate of the generic 2-by-2 X. + adj_coordinates = ((3, 1), (1, -1), (2, -1), (0, 1)) + result = {(): ONE} + for p in (X, Z): + q = mm(mm(target, p), star(target)) + t = {} + # Tr(Q X P adj(X)) = sum_(i,j,k,l) Q_ij X_jk P_kl adj(X)_li. + for i, j, k, ell in product(range(2), repeat=4): + coordinate, sign = adj_coordinates[2 * ell + i] + coefficient = times(mul(q[2 * i + j], p[2 * k + ell]), + F(sign, 2)) + merge_term(t, (2 * j + k, coordinate), coefficient) + h = word_times(word_add(word_mul(t, t), word_mul(t, determinant)), F(1, 2)) + result = word_mul(result, h) + require(result and all(len(w) == 8 for w in result), "wrong ordered degree") + for coefficient in result.values(): + require(all(z.denominator & (z.denominator - 1) == 0 for z in coefficient), + "ordered coefficient has an odd denominator") + return result + + +def tensor_coordinate(word): + """Coordinate in row-major vec(U tensor ... tensor U).""" + row = col = 0 + for position in word: + row = 2 * row + position // 2 + col = 2 * col + position % 2 + return row * (2 ** len(word)) + col + + +def coordinate_word(index, width): + """Independently unpack a row-major tensor coordinate.""" + row, col = divmod(index, 2 ** width) + return tuple(2 * ((row >> bit) & 1) + ((col >> bit) & 1) + for bit in range(width - 1, -1, -1)) + + +def evaluate_word(value, word): + answer = ONE + for position in word: + answer = mul(answer, value[position]) + return answer + + +def check(): + raw, reps = operators() + phase_cases = 0 + negative_local_factors = 0 + for target in reps: + for value in raw: + expected = ONE if canonical(value) == target else ZERO + interpolated = scalar_detector(target, value) + require(interpolated == expected, + "entry-enumerated interpolation failed") + if expected == ONE and det(value) in (I, neg(I)): + negative_local_factors += 1 + ell = times(tr(mm(star(target), value)), F(1, 2)) + for width in (8, 9, 11): + actual = mul(interpolated, power(ell, width - 8)) + # At a matching phase lift, ell is precisely that scalar phase. + wanted = power(ell, width) if expected == ONE else ZERO + require(actual == wanted, "phase-covariant padding failed") + phase_cases += 1 + require(negative_local_factors == 48, "phase cancellation control absent") + + rows = [ordered_row(a) for a in reps] + coordinates = {tensor_coordinate(w) for row in rows for w in row} + words = {w for row in rows for w in row} + require(len(words) == len(coordinates), "ordered tensor coordinates collide") + require(all(coordinate_word(tensor_coordinate(w), 8) == w for w in words), + "tensor word/coordinate convention disagrees") + # Width-eight one-qubit normalization is d^(f/2)=16. + columns = [{w: times(evaluate_word(a, coordinate_word(tensor_coordinate(w), 8)), + F(1, 16)) for w in words} for a in reps] + for i, row in enumerate(rows): + for j, column in enumerate(columns): + value = total(mul(times(c, 16), column[w]) for w, c in row.items()) + require(value == (ONE if i == j else ZERO), + "ordered tensor left inverse failed") + + faults = {} + for mode in ("unsigned", "omit_generator", "omit_determinant"): + faults[mode] = any(scalar_detector(a, b, mode) != (ONE if i == j else ZERO) + for i, a in enumerate(reps) for j, b in enumerate(reps)) + require(faults[mode], "detector fault escaped: " + mode) + faults["missing_normalization"] = any( + total(mul(c, columns[i][w]) for w, c in row.items()) != ONE + for i, row in enumerate(rows)) + require(faults["missing_normalization"], "normalization fault escaped") + faults["transpose_tensor_entry"] = any( + scalar_detector(a, (b[0], b[2], b[1], b[3])) != (ONE if i == j else ZERO) + for i, a in enumerate(reps) for j, b in enumerate(reps)) + require(faults["transpose_tensor_entry"], "coordinate transpose fault escaped") + + # Non-Clifford unitary control: CCZ at three qubits is Gaussian dyadic, + # unitary and determinant -1, but its X-generator correlations are 1/2. + signs = (1,) * 7 + (-1,) + correlations = [F(sum(signs[x] * signs[x ^ (1 << j)] for x in range(8)), 8) + for j in range(3)] + require(correlations == [F(1, 2)] * 3, "CCZ correlation control changed") + ccz_value = F(1) + for u in correlations + [F(1)] * 3: + ccz_value *= (u * u + u) / 2 + require(ccz_value == F(27, 512), "non-Clifford scope control changed") + return { + "status": "PASS_INDEPENDENT_CLIFFORD_DYADIC_LEFT_INVERSE", + "entry_enumerated_matrices": len(raw), + "projective_one_qubit_operators": len(reps), + "scalar_interpolation_pairs": len(raw) * len(reps), + "phase_padding_cases": phase_cases, + "matched_lifts_with_negative_local_factors": negative_local_factors, + "ordered_tensor_identity_entries": len(reps) ** 2, + "ordered_row_terms": sum(len(row) for row in rows), + "distinct_tensor_coordinates": len(coordinates), + "rejected_faults": sorted(faults), + "non_clifford_control": str(ccz_value), + "scope": "Independent one-qubit ordered-word calibration and three-qubit scope control; no four-qubit enumeration or physical cost claim.", + } + + +if __name__ == "__main__": + print(json.dumps(check(), indent=2, sort_keys=True)) diff --git a/research/clifford-dyadic-left-inverse/sources/canonical-obstruction.md b/research/clifford-dyadic-left-inverse/sources/canonical-obstruction.md new file mode 100644 index 0000000000..ca5067396e --- /dev/null +++ b/research/clifford-dyadic-left-inverse/sources/canonical-obstruction.md @@ -0,0 +1,183 @@ +# Odd division in the canonical Clifford decoder + +This is a scoped negative result with a written proof and exact arithmetic +certificates. It supplies a necessary coefficient requirement for one +decoder. No new kappa follows. + +## Statement and boundary + +Let `R=Z[i,1/2]`. Use the full projective four-qubit Clifford tensor map +`A_f` from the retained spectral proofs. Its columns are +`vec(U_a^(tensor f))/16^(f/2)`, one Gaussian-dyadic unitary per scalar +coset. There are `N=12,128,668,876,800` columns. The normalization +`16^(f/2)=2^(2f)` is a unit in R. Thus A_f has entries in R. Write + +```text +K_f = A_f* A_f, +B_f = A_f^+ = K_f^(-1) A_f*. +``` + +The star denotes conjugate transpose. The +[odd-width proof](https://github.com/aliromman/integer-mult-bounds/blob/9a8ce06644700ffa576d99316450bcb52835d6dc/research/clifford-odd-width-spectrum/PROOF.md) +and the +[Bell-sector proof](https://github.com/aliromman/integer-mult-bounds/blob/a5aa2ae21ae68338390f584b8fca58ecba0df409/research/clifford-bell-sector-spectrum/PROOF.md) +give full column rank for every odd f>=13 and every f>=14 with +f=2 modulo 4. At every such width, neither K_f^(-1) nor B_f has all +entries in R. + +More precisely, the proof gives one positive odd integer M_f>1. +If a positive odd integer D clears all odd denominators of K_f^(-1), +then M_f divides D. If D clears all odd denominators of B_f, then +M_f divides D^2. Consequently every prime divisor of M_f must be +available in any rational localization of R that contains either map. +These are necessary conditions. They need not suffice. + +A finite linear circuit with coefficients in R and clean auxiliary +registers has an input-output matrix in R. It therefore cannot implement +the exact full canonical map B_f on arbitrary observations. This does +not rule out another left inverse, a restricted input contract, a +subalphabet, approximation, or a scalar service with odd division. +Widths divisible by four are outside this theorem. + +## 1. A rational-eigenvalue lemma + +If a finite square matrix C over R has a rational eigenvalue r, then +r belongs to Z[1/2]. Indeed, its monic characteristic polynomial q has +coefficients in R. The product of q with its coefficientwise conjugate +is monic, has coefficients in Z[1/2], and has r as a root. Write r=a/b +in lowest terms. Clear the powers of two in this monic equation and +multiply by the required power of b. Reduction modulo any odd prime +dividing b leaves a nonzero leading term and zero for every other term. +This is a contradiction. Thus b is a power of two. + +The same proof works over Z[i,1/2,1/S] for a set S of odd primes. +Every odd prime in the reduced denominator of r must belong to S. +No statement about irrational eigenvalues is needed. + +## 2. One eigenvalue at every covered width + +The trivial quotient row in the odd sector has eigenvalue P(x). The +trivial minus-stabilizer row in the Bell sector has eigenvalue H(x). +Both are actual blocks of the full Gram matrix, not just a submatrix. +Their coefficient lists, in increasing degree, are + +```text +P: [1, 255, 32300, 2034900, 63083328, 946249920, + 6623744000, 19871232000, 19871236096] +H: [1, 136, 8619, 271320, 4205460, 31541664, + 110396096, 165593600, 82796544]. + +Odd sector: p=(f-1)/2, sigma=(-1)^floor((f+1)/4). +Bell sector: p=(f-2)/2, sigma=(-1)^(p/2). +Both: x=sigma*2^(-p), p>=6. +``` + +The Bell exponent p is even. The following calculation works for either +sign and every integer p>=6. For coefficients a_r, the valuations and +the gaps from the degree-eight term at p=6 are + +| Polynomial | v_2(a_0),...,v_2(a_8) | Gaps for r=0,...,7 | +|---|---|---| +| P | 0,0,2,2,6,6,12,12,16 | 32,26,22,16,14,8,8,2 | +| H | 0,3,0,3,2,5,6,9,13 | 35,32,23,20,13,10,5,2 | + +For general p the r-th gap increases by `(8-r)(p-6)`. Every gap +is positive. The degree-eight term is therefore the unique term of +least 2-adic valuation. It cannot cancel. In lowest terms, + +```text +P(sigma*2^(-p)) = M_f / 2^(8p-16), M_f odd, +H(sigma*2^(-p)) = M_f / 2^(8p-13), M_f odd. +``` + +It remains to exclude M_f=1. All coefficients are positive, so the +value at positive x is at least one. For negative x, put x=-y/64. +The retained certificates express P(-y/64) and H(-y/64) in the +degree-eight Bernstein basis on [0,1]. This basis is nonnegative and +sums to one. The least coefficients are respectively + +```text +470624175 / 2^32, +5741614935 / 2^35. +``` + +The checker expands both certificates into the power basis exactly. +Since the reduced denominators above are at least 2^32 and 2^35, +respectively, M_f is at least 470624175 or 5741614935. In particular, +M_f is positive, odd and greater than one at every covered width. + +## 3. Inverse and decoder consequences + +The reciprocal of the selected eigenvalue is `2^e/M_f`. If D times +K_f^(-1) has entries in R, the rational-eigenvalue lemma applied to +that matrix gives `D*2^e/M_f` in Z[1/2]. Since M_f is odd, M_f divides D. +Taking D=1 proves the Gram inverse obstruction. + +For the canonical map, direct multiplication gives + +```text +B_f B_f* = K_f^(-1) A_f* A_f K_f^(-1) = K_f^(-1). +``` + +If D times B_f has entries in R, then D^2 times K_f^(-1) has entries +in R. Thus M_f divides D^2. In particular B_f cannot have all entries +in R. If `M_f=product q^e_q`, every such odd D is a multiple of +`product q^ceil(e_q/2)`. This divisor is a lower bound, not a claimed +minimum denominator for the complete matrix. + +At width 13 the selected numerator is +`3^6*5^2*7^2*17*31=470624175`; the decoder divisor is 498015. +At width 14 it is `3^6*5*7^2*17*31*61=5741614935`; the decoder +divisor is 30378915. Both factorizations are checked by complete trial +division. Other blocks or projectors may impose additional factors. + +The denominator argument is classical localization arithmetic. Nick +Petalas's related +[helper-capacity theorem](https://github.com/petalas/integer-mult-bounds/blob/7de4bd6bd4a6f7fae59b90c941ae5a3b9b3e652d/research/odd-budget-helper-capacity/PROOF.md) +uses Smith factors to obtain exact two-sided budgets for a different +real pairing contract. We do not claim priority for that arithmetic or +reuse its capacity conclusion here. + +## 4. The left-inverse distinction is necessary + +For `A=(1,2)^T`, the Gram scalar is 5. The canonical decoder is +`A^+=(1/5,2/5)`, which is not dyadic. However, `(1,0) A=1` gives a +dyadic left inverse on noise-free data. The checker verifies this +example. Thus a Gram denominator obstruction alone cannot exclude +every exact recovery map on the image of A. The theorem concerns the +canonical map on the entire observation space. + +## Verification and limits + +The executable authenticates eight retained files. It checks both +symbolic valuation arguments and both positive polynomial identities. +It corroborates them at 59 odd widths from 13 through 129 and 30 Bell +widths from 14 through 130. The proof supplies the infinite quantifier. + +A separate calculation constructs all 24 one-qubit projective +operators, checks their 576 products, and forms their full width-six +normalized Gram matrix. Exact Gaussian elimination gives an inverse +whose common denominator is 45 and whose first diagonal entry is 10/9. +Both matrix products are checked against the identity, for 1,152 scalar +entries in total. This is a small-case calibration, not a four-qubit +matrix expansion. Six controls reject altered valuations, invalid +certificates and wrong width domains. A dyadic-unit scalar supplies a +positive control. + +The spectral proofs and their character-table identifications remain +mathematical inputs. Their source suites and table archive are not +replayed here. Only generic Gaussian operations are imported from the +retained conditioning checker. No full four-qubit inverse, arbitrary +left-inverse classification, physical decoder, Lean or independent +human acceptance is supplied. Preparation, odd division, precision, +routing, storage, restoration and the complete caller remain unpriced. +All five assumptions and the selected frontier remain unchanged. + +## Open next questions + +Find sufficient common denominators for the full canonical inverse. +The one-block necessary divisor does not settle that question. + +Determine whether the saturated column module admits a different +Gaussian-dyadic left inverse. This requires module information beyond +the Gram spectrum. diff --git a/research/clifford-dyadic-left-inverse/sources/clifford-ring.md b/research/clifford-dyadic-left-inverse/sources/clifford-ring.md new file mode 100644 index 0000000000..9f89ee36a0 --- /dev/null +++ b/research/clifford-dyadic-left-inverse/sources/clifford-ring.md @@ -0,0 +1,430 @@ +# The three-qubit Clifford tensor threshold is ten + +This is a scoped algebraic theorem about the complete Gaussian-dyadic +three-qubit Clifford alphabet. It gives no new multiplication exponent, +physical supplier, or implementation of the five assumptions retained by +the selected construction. Classical finite-group representation theory +and the cited character table are premises; the proof is not a proof-assistant +formalization or independent human review. + +## 1. Statement and conventions + +Let `D = Z[i,1/2]`, and let `G` be the group of all unitary three-qubit +Clifford matrices with entries in `D`. Its natural representation `V` has +dimension eight. Let `z=iI`. The scalar subgroup is + + Z = = {I,iI,-I,-iI}. + +Let `P` be the Pauli subgroup generated by `z` and the three pairs `X_j,Z_j`. +Then `|P|=256`, `G/P = Sp(6,2) = S`, and + + |S| = 1,451,520, + |G/Z| = 64 |S| = 92,897,280, + |G| = 4 |G/Z| = 371,589,120. + +The usual Pauli and symplectic conventions are those of the retained +pointwise-faithfulness and two-qubit-centre packages. The Gaussian-dyadic +group has scalar kernel `mu_4`, not `mu_8`. Indeed, if `(a+bi)/2^k` has +modulus one, successive parity division in `a^2+b^2=2^(2k)` reduces it to +one of the four Gaussian units. The Gaussian-dyadic gates `S`, +`((1+i)I+(1-i)X)/2`, and CNOT realize the standard symplectic generators; +thus the quotient is the full `Sp(6,2)`. The Pauli action determines a +Clifford up to scalar. + +Choose one unitary representative `U_a` for each `a in G/Z`, with `U_1=I`. +Define + + H_f(a,b) = (tr(U_a^* U_b)/8)^f, f = 1,2,... . + +This is the Gram matrix of `U_a^(tensor f)/8^(f/2)` in Hilbert-Schmidt +space. Changing the representatives conjugates `H_f` by a diagonal +unitary matrix and does not change its rank or spectrum. + +**Theorem.** The least width at which this projective alphabet is linearly +independent is exactly **ten**. Equivalently, its least eventual pointwise +threshold is + + T(3) = 10. + +At width nine the nullity is exactly `56^2 = 3,136`, so + + rank H_9 = 92,894,144. + +For every integer `f >= 10`, the following additional, nonoptimal bounds hold: + + (945/262144) I <= H_f <= (762615/32768) I. (1) + +The resulting Gram condition-number bound is 6,456. We do not claim sharp +spectral constants. In particular, the threshold is not the extrapolated +value `4n+1=13` suggested by the one- and two-qubit cases. + +## 2. Why tensor independence is an irreducible-support question + +For each `r mod 4`, let `A_r` be the central-character ideal of `C[G]` on +which `z` acts as `i^r`. Its dimension is `|G/Z|`, and one representative +per projective class gives a basis after projection to this ideal. +The representation `V^(tensor f)` annihilates the other three ideals. + +By semisimplicity, + + A_r = direct_sum_{rho : rho(z)=i^r I} End(rho). + +The representation of `A_r` is injective exactly when every irreducible +in this sector occurs. A missing irreducible of dimension `d` removes +an entire matrix block of dimension `d^2`. Thus + + rank H_f = sum_{rho occurring in V^(tensor f)} (dim rho)^2. (2) + +If `m_rho(f)` is its multiplicity, the normalized Gram eigenvalue on its +regular matrix block is + + lambda_rho(f) = |G/Z| m_rho(f) / (8^f dim rho). (3) + +One way to check the normalization is to use central convolution on all +of `G`, whose eigenvalue is `|G| m_rho(f)/dim rho`. Combining the four +scalar lifts multiplies the projective Gram by `4*8^f`; dividing gives +(3). The regular multiplicity is `(dim rho)^2`, not four times that value. + +## 3. The odd central sector and a smaller character calculation + +The Pauli group has a unique irreducible with `z` acting by `i`, namely +the eight-dimensional restriction of `V`. This follows directly from +the usual irreducible representation of the three Pauli pairs; its +matrix algebra has dimension 64. Consequently every irreducible of `G` +in central sector `i` has the unique form + + V tensor sigma, sigma in Irr(S). (4) + +For completeness, for such a representation `R`, the multiplicity space +`Hom_P(V,R)` carries the honest quotient action + + g . phi = R(g) phi V(g)^(-1). + +Pauli elements act trivially on this space. Evaluation identifies +`R` with `V tensor Hom_P(V,R)`, and irreducibility on one side is equivalent +to irreducibility of the multiplicity space. No splitting of `G` over `P` +is being assumed. The actual natural representation supplies the extension +needed in (4). + +Let `s in S`, and put `d(s)=dim_F2 ker(s-I)`. Among the 64 projective +Pauli lifts of `s`, exactly `2^(6-d(s))` have nonzero trace; on each such +lift `g`, + + |tr V(g)|^2 = 2^d(s). (5) + +To recall the argument, conjugation on the Hermitian Pauli basis is a +signed permutation. Its trace is `|tr V(g)|^2`. The signs on the fixed +label space form a binary character, so their sum is zero or `2^d`. +Multiplication by Paulis runs through all its characters equally often. +In particular there is always a nonzero-trace lift. + +For a Gaussian-dyadic number of squared modulus `2^d`, its fourth power is + + (tr V(g))^4 = (-1)^d 2^(2d). (6) + +This includes the phase: writing the number as `(a+bi)/2^k`, the equation +`a^2+b^2=2^(d+2k)` implies that, after removing common powers of two, +either one coordinate is zero or the coordinates have equal absolute +value. The two cases give the sign in (6). + +For `f=4t+1`, write + + V^(tensor f) = V tensor W_f. + +The quotient representation `W_f` is honest, and the character product +on a nonzero-trace lift gives + + chi_W_f(s) = (-1)^(dt) 2^(2dt). (7) + +In particular, + + chi_W_9(s) = 2^(4d(s)). (8) + +This is also the permutation character of `S` acting on ordered +four-tuples of vectors in `F_2^6`. Thus the width-nine input to the proof +is an ordinary 30-character calculation for `Sp(6,2)`, rather than a +92,897,280-by-92,897,280 Gram calculation. + +## 4. Exact width-nine decomposition + +We use the published character table of Chin-Yen Lee, Wei-Hsuan Yu, +Yung-Ning Peng and Ching-Jui Lai, [arXiv:2309.14850v2](https://arxiv.org/html/2309.14850v2#S6.SS3), Section 6.3, +and its Section 5.2 identification of the adjoint character as +`1 + chi_10`. The package retains the exact transcribed table and the +class-fibre extraction. Inflated characters are those trivial on the +64-element projective Pauli subgroup. The executable checks character +orthogonality, class and degree sums, the quotient extraction, fixed-space +trace data, and every integer inner product below. Those checks validate +the transcription and calculation; they do not independently reconstruct +the published character table from group multiplication. + +More explicitly, the nonidentity projective Paulis constitute one +63-element conjugacy class. A character is trivial on this subgroup +exactly when its value on that class equals its degree: equality in the +unitary trace bound forces the matrix to be the identity. These are +precisely the inflated quotient irreducibles. Two source classes have the +same quotient class exactly when all these characters agree, since +irreducible characters separate conjugacy classes. Each quotient class +size is the sum of its source class sizes divided by 64. Finally, the +maximum of the adjoint value `1+chi_10` over a quotient fibre is `2^d` +by (5). This identifies the fixed-space data used in (8), including the +63-element transvection class, without inferring `d` from class order alone. + +Taking inner products of (8) with the quotient characters gives the +following complete list. Repeated degrees denote distinct irreducibles, +in their retained source order. + +| Degree | Multiplicity in `W_9` | +|---:|---:| +| 1 | 269 | +| 7 | 0 | +| 15 | 85 | +| 21 | 35 | +| 21 | 840 | +| 27 | 1890 | +| 35 | 1975 | +| 35 | 175 | +| 56 | 28 | +| 70 | 350 | +| 84 | 1407 | +| 105 | 210 | +| 105 | 2625 | +| 105 | 1575 | +| 120 | 3900 | +| 168 | 4410 | +| 189 | 945 | +| 189 | 567 | +| 189 | 2835 | +| 210 | 5250 | +| 210 | 2625 | +| 216 | 1728 | +| 280 | 5600 | +| 280 | 1400 | +| 315 | 1575 | +| 336 | 2940 | +| 378 | 2835 | +| 405 | 6075 | +| 420 | 5250 | +| 512 | 5440 | + +The multiplicity-weighted dimensions sum to `8^8=16,777,216`. Let `sigma_0` denote the sole +missing character, of degree seven. On a symplectic transvection `tau`, + + chi_sigma_0(tau) = -5. (9) + +This is the class of size 63 with fixed-space dimension five. The +nonzero multiplicities in the table also satisfy + + (1/2) dim sigma <= m_sigma(9) <= 269 dim sigma. (10) + +The only missing irreducible in `V^(tensor 9)` is therefore +`rho_0=V tensor sigma_0`, of dimension 56. Equation (2) proves the +claimed nullity and rank. + +There is an explicit null witness. For a projective representative `U_a`, +let `s_a` be its symplectic image and define + + b_a = chi_rho_0(U_a^(-1)) + = conjugate(tr V(U_a) * chi_sigma_0(s_a)). + +Then + + sum_a b_a U_a^(tensor 9) = 0. (11) + +Indeed, the central primitive idempotent + + (56/|G|) sum_{g in G} chi_rho_0(g^(-1)) [g] + +acts as zero in `V^(tensor 9)`. Grouping its four scalar lifts gives +(11), since their factors `i^(-j)` and `i^(9j)` cancel. This is a +nonzero coefficient vector: its coefficient at the identity is 56. +It is a width-nine relation, not an all-width identity. + +## 5. The even sector is controlled by quadratic forms + +Consider any irreducible `mu` of `G` with `mu(z)=-I`, the sector of +`V^(tensor 10)`. Its restriction to `P` is a sum of one-dimensional +characters because `[P,P]=<-I>` and `mu(-I)=I`. + +Write a binary label as `v=(a,b)` and use the Hermitian Pauli convention + + W_v = i^(a.b) X^a Z^b. + +The one-dimensional characters with `z` acting by `-1` are indexed by +the 64 quadratic forms with polar form the standard symplectic form: + + Q_(alpha,beta)(a,b) = a.b + alpha.a + beta.b, + lambda_Q(W_v) = (-1)^Q(v). + +In a Clifford conjugation `W_v -> +/- W_(s v)`, the sign has no effect +on `lambda_Q`, since it sends `-I` to one. The quotient therefore acts +on these characters by its ordinary action on quadratic forms. + +There are exactly two orbits, distinguished by Arf invariant, + + Arf Q_(alpha,beta) = alpha.beta. + +Their sizes are 36 and 28. This is the standard symplectic classification +of nondegenerate binary quadratic forms: choosing successive hyperbolic +pairs gives one normal form for each Arf value. The counts also follow +directly by summing over `alpha,beta`. + +Since `mu` is irreducible, its Pauli character spaces form one transitive +orbit and have a common dimension `a>=1`. Hence for one `N in {28,36}`, + + mu restricted to P = a sum_{Q in orbit} lambda_Q, + dim mu = N a. (12) + +For a nonzero vector `v`, the symplectic transvection is + + tau_v(x) = x + omega(x,v) v. + +The quadratic identity gives + + Q(tau_v x) = Q(x) + omega(x,v)(Q(v)+1). + +Thus a form is fixed exactly when `Q(v)=1`. Each Arf orbit has exactly +16 such forms. For example, use symplectic coordinates with `v=e_1`. +Then `alpha_1=1`; the four coordinates +`alpha_2,alpha_3,beta_2,beta_3` are arbitrary, and `beta_1` is uniquely +fixed by the prescribed Arf invariant. + +Any Clifford lift `g` of this transvection permutes the Pauli character +spaces. Only the sixteen fixed spaces contribute to its trace. Since +the representation can be made unitary, each contributes absolute trace +at most `a`. Consequently + + |chi_mu(g)| <= 16 a. (13) + +This bound uses neither the character table of the even central sector +nor extensions of its stabilizer representations. + +## 6. Every irreducible occurs at width ten + +Suppose, for contradiction, that `mu` is missing from `V^(tensor 10)`. +Tensor reciprocity gives + + = . + +The representation on the right has central character `i`. The sole +irreducible absent from `V^(tensor 9)` is `rho_0`. All multiplicities are +nonnegative integers, so absence forces + + conjugate(V) tensor mu = m rho_0, m >= 1. + +Dimensions give `7m=Na`. Take `g=S` on the first qubit and the identity +on the other two. Its symplectic image is a transvection and +`tr V(g)=4(1+i)` is nonzero. The character identity and (9) imply + + |chi_mu(g)| = 5m = (5N/7)a. + +For `N=28` this is `20a`; for `N=36` it is `180a/7`. Both exceed `16a`, +contradicting (13). Therefore no even-sector irreducible is missing. +By Section 2, `H_10` is positive definite. + +This argument is also a useful check against a phase error: conjugate `V`, +not `V`, is used in reciprocity, and the relevant Pauli character orbit is +the quadratic-form orbit for central character `-1`. + +## 7. Quantitative bounds and every larger width + +The same reasoning gives (1) without computing the full even-sector +spectrum. Decompose + + conjugate(V) tensor mu = sum_sigma n_sigma (V tensor sigma), + d_mu := dim mu = sum_sigma n_sigma dim sigma. + +Let `n_0` be the coefficient of the missing degree-seven character and +put `R=d_mu-7n_0`. At the transvection lift used above, the character +identity and the elementary bound +`|chi_sigma(tau)|<=dim sigma` give + + 12n_0-d_mu + = 5n_0-R + <= |sum_sigma n_sigma chi_sigma(tau)| + = |chi_mu(g)| + <= 16a. + +The first inequality is valid even when its left side is negative. +Using `d_mu=Na` and `N in {28,36}` yields + + R >= a(5N-112)/12 >= d_mu/12. + +Reciprocity and (10) now show + + d_mu/24 <= m_mu(10) <= 269 d_mu. + +Substituting into (3) gives precisely (1) at width ten. The lower bound +also proves positivity directly. + +Finally, + + H_(f+1) = H_f Hadamard H_1. + +The Schur product theorem and the unit diagonal of `H_1` imply + + alpha I <= H_f <= beta I + => alpha I <= H_(f+1) <= beta I. + +This proves (1), hence independence, at every `f>=10`. If any smaller +positive width were independent, the same Schur step would make width +nine independent, contrary to Section 4. The threshold is therefore +exactly ten, not just an upper bound. + +## 8. Four fixed-residual tests with exact phases + +Let a fixed residual in `C[G]` have coefficients `c_(a,j)` on the exact +operators `i^j U_a`, after equal operators are combined. For `r mod 4`, set + + beta_(a,r) = sum_{j=0}^3 c_(a,j) i^(jr). + +At width `f`, its operator evaluation is + + sum_a beta_(a,f mod 4) U_a^(tensor f). + +Pointwise independence at the four widths `10,11,12,13` makes these +evaluations zero exactly when all four sets of `beta` coefficients are +zero. Fourier inversion then gives `c_(a,j)=0` for every exact operator. +Consequently the following are equivalent for a fixed residual: + +1. Every exact-operator coefficient vanishes. +2. Its evaluation vanishes at every positive tensor width. +3. Its evaluations vanish at widths 10, 11, 12 and 13. + +If `M=sum_(a,j)|c_(a,j)|^2`, Parseval and (1) imply that at least one of +those four evaluations has normalized squared Hilbert-Schmidt norm at +least `(945/262144) M`. Coefficients must be fixed for this four-test +statement; pointwise independence itself allows coefficients to depend +on the chosen width. + +Four residue classes remain necessary for unrestricted fixed residuals: +`sum_j i^(-rj)[i^j I]` vanishes outside residue `r` and is nonzero in that +residue. The four-test count and the scalar Fourier argument are retained +predecessor principles; this theorem supplies the earlier sufficient window. + +## 9. Scope and attribution + +The alphabet is the full projective three-qubit Clifford group, with arbitrary +complex coefficients at a fixed width. The theorem is not a statement about +arbitrary sums of Cliffords as individual alphabet elements, operators coupling +tensor columns, nonlinear rounded gates, or nonunitary stabilizer maps. +It supplies no paid-call bound without a separate source-bound caller argument. +The selected conditional multiplication result and its five assumptions are +unchanged. + +Ali Romman's pointwise-faithfulness package supplies the general Clifford +framework, trace distribution, phase-residue interpretation, and open sharp +threshold question. MatShep's one- and two-qubit packages supply the earlier +sharp cases and the Schur-propagation method. The linear-lower-bound package +records the unresolved three-qubit case. The authors of arXiv:2309.14850 +supply the published character table and adjoint identification; their table +is a cited mathematical input, not newly constructed here. Pauli representation +theory, tensor reciprocity, character orthogonality, binary quadratic-form +classification, central idempotents and the Schur product theorem are classical. + +The new contribution is the exact width-nine decomposition and its missing +block, the even-sector transvection argument proving full support at ten, +and their quantitative and fixed-residual consequences. Prepared with +substantial OpenAI Codex assistance and separate agent proof/checking work. +No independent human acceptance or proof-kernel certification is claimed. +New material is Apache-2.0; retained sources keep their attribution and license. diff --git a/research/clifford-dyadic-left-inverse/sources/four-qubit-map.md b/research/clifford-dyadic-left-inverse/sources/four-qubit-map.md new file mode 100644 index 0000000000..75c4dd2844 --- /dev/null +++ b/research/clifford-dyadic-left-inverse/sources/four-qubit-map.md @@ -0,0 +1,269 @@ +# Exact spectral endpoints at every odd width + +This is a written algebraic proof with exact finite certificates. It +does not construct or price a physical decoder. + +## Result + +Use the full four-qubit Gaussian-dyadic Clifford group `G`, its natural +representation `V` of dimension 16, the Pauli subgroup `P`, and the +scalar subgroup `Z = `. Let `S = G/P = Sp(8,2)`. There are +`N = |G/Z| = 12,128,668,876,800` scalar cosets. + +Choose a unitary representative `U_a` of each coset. At width `f`, let +`A_f` have columns `vec(U_a^(tensor f))/16^(f/2)`. Its normalized Gram +matrix is + +```text +K_f(a,b) = (tr(U_a* U_b)/16)^f. +``` + +The star means conjugate transpose. A different choice of representatives +gives diagonal unitary conjugation and does not change the spectrum. + +For an odd integer `f >= 13`, set + +```text +p = (f-1)/2, +sigma = (-1)^floor((f+1)/4), +x = sigma 2^(-p). + +P(x) = 1 + 255x + 32300x^2 + 2034900x^3 + 63083328x^4 + + 946249920x^5 + 6623744000x^6 + + 19871232000x^7 + 19871236096x^8. + +Q(x) = 1 - 153x + 9860x^2 - 310284x^3 + 4806240x^4 + - 36044352x^5 + 126164480x^6 + - 189259776x^7 + 94633984x^8. +``` + +The following endpoints are exact and have the stated full eigenspaces. + +| Width modulo 8 | Minimum | Minimum dimension | Maximum | Maximum dimension | +|---|---|---:|---|---:| +| 1 or 7 | `Q(x)` | 313,600 | `P(x)` | 256 | +| 3 or 5 | `P(x)` | 256 | `Q(x)` | 313,600 | + +Both endpoints are positive. No other irreducible block attains either +endpoint at a finite width in this domain. The exact Gram condition +number is the maximum divided by the minimum. The condition number of +`A_f` is its square root. The norm of the least-squares coefficient +recovery map on the full span is the reciprocal square root of the +minimum. These are sharp constants for this normalized full alphabet. + +All 81 spectral blocks are given by degree-eight polynomials in the +certificate. This extends the single-width spectrum in +[PR #7772](https://github.com/CrocSwap/integer-mult-bounds/pull/7772). +It does not change the threshold `T(4)=13` or any multiplication bound. + +## 1. The phase at every odd width + +We use the exact group and Pauli-sector identification from +[alephnan's proof](https://github.com/alephnan/integer-mult-bounds/blob/f7f32a18dde54e67624a9ed9cc7e1b266d9585c0/research/clifford-three-qubit-threshold/PROOF.md) +and the Gaussian trace argument in +[the four-qubit threshold proof](https://github.com/aliromman/integer-mult-bounds/blob/d7c2dd1868c70f0addce2c0a4d3220149452f14b/research/clifford-four-qubit-threshold/PROOF.md). +For a symplectic element with fixed-space dimension `d`, choose a Pauli +lift with nonzero trace `a`. Then + +```text +|a|^2 = 2^d, +a^4 = (-1)^d 2^(2d). +``` + +The first statement follows from the signed permutation action on the +Hermitian Pauli basis. The signs on fixed labels form a character, and +Pauli translations supply all such characters. The second statement +follows from the Gaussian-dyadic sum-of-two-squares equation: after +removing the dyadic factor, an even exponent gives an axial Gaussian +integer and an odd exponent gives equal absolute real and imaginary +parts. Its fourth power has the displayed sign. + +If `f = 1 mod 4`, the unique Pauli irreducible in the tensor power's +central sector is `V`. If `f = 3 mod 4`, it is the conjugate `Vbar`. +Therefore the honest quotient representation `W_f` satisfies + +```text +V^(tensor f) = V tensor W_f when f = 1 mod 4, +V^(tensor f) = Vbar tensor W_f when f = 3 mod 4. +``` + +Character division on the chosen lift gives, respectively, +`a^(f-1)` and `a^(f+1)/|a|^2`. In both cases, + +```text +chi_(W_f)(s) = sigma^d 2^(p d), +dim(W_f) = 2^(8p). +``` + +In particular, the sign is positive at widths 15 and 17, and negative +at widths 13 and 19. Keeping the width-thirteen sign at every odd width +would give the wrong representation. + +## 2. All spectral polynomials + +The mathematical input is the ordinary `Sp(8,2)` character table through +[Nick Petalas's exact projection](https://github.com/petalas/integer-mult-bounds/blob/ff12ca358d601a21cd4b1f016b8a3a969ac44016/research/clifford-four-qubit-width-nine/PROJECTION.json). +Its retained source names the ATLAS and Thomas Breuer's CTblLib 1.3.11. +Let `e_j` be the degree of row `j`, and let `C_(j,d)` be the sum of +class size times that character over elements with fixed dimension `d`. +The projection supplies `d=1,...,7`. Identity gives `C_(j,8)=e_j`. +Character orthogonality gives + +```text +C_(j,0) = |S| [j=1] - sum_(d=1)^8 C_(j,d), +|S| = 47,377,612,800. +``` + +These aggregate sums are real integers. The tensor multiplicity and +normalized projective Gram eigenvalue are + +```text +m_j(f) = (1/|S|) sum_(d=0)^8 C_(j,d) sigma^d 2^(p d), +lambda_j(f) = |S| m_j(f) / (e_j 2^(8p)). +``` + +The projective regular block has dimension `(16 e_j)^2`. The eigenvalue +normalization is the same for `V` and `Vbar`. It follows either from +central convolution and the four scalar lifts, or from the retained +[width-thirteen normalization proof](https://github.com/aliromman/integer-mult-bounds/blob/1398fbdca3536389d8ac3c8b3aaa408f03e8f6c2/research/clifford-threshold-conditioning/PROOF.md). + +Since `sigma^8=1`, define + +```text +P_j(x) = sum_(r=0)^8 (C_(j,8-r)/e_j) x^r. +``` + +Then `lambda_j(f)=P_j(x)`. The first row has degree one and polynomial +`P`; the second row has degree 35 and polynomial `Q`. +The certificate records every coefficient of all 81 polynomials. + +Two whole-polynomial checks verify the complete normalization. If `c_d` +is the number of symplectic elements with fixed dimension `d`, then + +```text +sum_j e_j^2 P_j(x) = |S|, +sum_j e_j^2 P_j(x)^2 = |S| sum_(r=0)^8 c_(8-r) x^(2r). +``` + +The first is the normalized Gram trace. The second also follows directly +from Pauli lifts: each symplectic element has `2^(8-d)` nonzero projective +Pauli traces of squared modulus `2^d`. The checker compares every +coefficient, including the vanishing odd coefficients of the second +identity. This is stronger than checking these moments at a list of +widths. + +## 3. Finite certificates for the infinite width range + +For positive `x` in the actual domain, `0 < x <= 1/128`. For negative +`x`, `-1/64 <= x < 0`. The two finite interval statements are + +```text +Q(x) < P_j(x) < P(x) for 0 < x <= 1/128, +P(x) < P_j(x) < Q(x) for -1/64 <= x < 0, +``` + +with only the designated endpoint row omitted from its own strict +inequality. Each pair of distinct endpoint rows occurs once. There +are 159 comparisons per interval, or 318 in total. + +For each comparison `P_a < P_b`, substitute `x = sigma y/D`, where +`D=128` or `64`. All polynomials have constant term one. Hence + +```text +P_b(sigma y/D) - P_a(sigma y/D) = y q(y), +degree(q) <= 7. +``` + +The certificate writes this quotient in the degree-seven Bernstein basis: + +```text +q(y) = sum_(j=0)^7 b_j binom(7,j) y^j (1-y)^(7-j). +``` + +All 2,544 rational coefficients `b_j` are strictly positive. Their +minimum is `45984105/1073741824`. The basis terms are nonnegative and +sum to one on `0 <= y <= 1`. Therefore `q(y)>0`, and `y q(y)>0` for +`0 0 and denominator & (denominator - 1) == 0, + 'odd coefficient denominator') + + +def tensor_index(alpha): + row = col = 0 + f = sum(alpha) + for coordinate, multiplicity in enumerate(alpha): + for _ in range(multiplicity): + row = 2 * row + coordinate // 2 + col = 2 * col + coordinate % 2 + return row * (2 ** f) + col + + +def tensor_coordinate(u, f, index): + row, col = divmod(index, 2 ** f) + out = ONE + for bit in range(f - 1, -1, -1): + out = qm(out, u.get(((row >> bit) & 1, (col >> bit) & 1), ZERO)) + return out + + +def kronecker(a, b, bd): + return {(i * bd + k, j * bd + l): qm(x, y) + for (i, j), x in a.items() for (k, l), y in b.items() + if qm(x, y) != ZERO} + + +def row_evaluation(poly, u, f, normalization): + require(f % 2 == 0, 'one-qubit normalized check requires even width') + out = ZERO + for alpha, coefficient in poly.items(): + # Observe the literal normalized tensor coordinate, not a monomial evaluator. + observation = qm(tensor_coordinate(u, f, tensor_index(alpha)), (F(1, 2 ** (f // 2)), 0)) + out = qa(out, qm(qm(coefficient, (normalization, 0)), observation)) + return out + + +def embedded(g, n, qubit): + out = {} + for col in range(2 ** n): + source_bit = (col >> qubit) & 1 + for dest_bit in (0, 1): + value = g.get((dest_bit, source_bit), ZERO) + if value != ZERO: + row = (col & ~(1 << qubit)) | (dest_bit << qubit) + out[row, col] = value + return out + + +def cnot(n, control, target): + return {(col ^ ((1 << target) if (col >> control) & 1 else 0), col): ONE + for col in range(2 ** n)} + + +def pauli(n, x, z): + phase = qp(I, (x & z).bit_count() % 4) + return {(col ^ x, col): qm(phase, ((-1) ** ((z & col).bit_count() % 2), 0)) + for col in range(2 ** n)} + + +def four_qubit_samples(): + gates = {'H' + str(q): embedded(H, 4, q) for q in range(4)} + gates.update({'S' + str(q): embedded(S, 4, q) for q in range(4)}) + gates.update({'C01': cnot(4, 0, 1), 'C12': cnot(4, 1, 2), + 'C23': cnot(4, 2, 3)}) + words = [(), ('H0',), ('S0',), ('H1',), ('S1',), ('H2',), ('S2',), + ('H3',), ('S3',), ('C01',), ('C12',), ('C23',), + ('H0', 'C01', 'S1'), ('S2', 'H2', 'C23', 'H3'), + ('H0', 'H1', 'H2', 'H3'), ('C01', 'S1', 'C12', 'H2', 'C23')] + samples = [] + for word in words: + u = mi(16) + for name in word: + u = mm(gates[name], u) + samples.append(u) + require(len({projective_key(u) for u in samples}) == len(samples), + 'duplicate four-qubit sample') + return samples + + +def authenticate(item, data): + require(len(data) == item['bytes'], 'source length changed') + require(sha256(data).hexdigest() == item['sha256'], 'source SHA256 changed') + git_object = b'blob ' + str(len(data)).encode('ascii') + b'\0' + data + require(sha1(git_object).hexdigest() == item['git_blob'], 'source Git blob changed') + + +def main(): + started = time.monotonic() + pins = json.loads((ROOT / 'SOURCE-PINS.json').read_text())['files'] + require(len(pins) == 3, 'source coverage changed') + source_controls = 0 + for item in pins: + data = (ROOT / item['path']).read_bytes() + authenticate(item, data) + mutated = bytes([data[0] ^ 1]) + data[1:] + source_controls += rejected(lambda: authenticate(item, mutated), 'source byte') + + group = one_qubit_group() + polynomials, factor_lists = zip(*(polynomial_for(u) for u in group)) + for poly in polynomials: + homogeneous(poly, 8) + dyadic_coefficients(poly) + require(len({tensor_index(alpha) for alpha in poly}) == len(poly), + 'tensor lift merged distinct monomials') + coefficients = sum(map(len, polynomials)) + for a, poly in enumerate(polynomials): + for b, u in enumerate(group): + require(row_evaluation(poly, u, 8, 16) == (ONE if a == b else ZERO), + 'one-qubit normalized left inverse failed') + + # Literal Kronecker construction independently fixes the flattening convention. + calibration = mm(S, H) + literal = mi(1) + for _ in range(4): + literal = kronecker(literal, calibration, 2) + for index in range(256): + require(literal.get(divmod(index, 16), ZERO) == tensor_coordinate(calibration, 4, index), + 'literal Kronecker index mismatch') + + samples = four_qubit_samples() + generators = [embedded(p, 4, q) for q in range(4) for p in (PX, PZ)] + signed_paulis = set() + for x, z in product(range(16), repeat=2): + p = pauli(4, x, z) + signed_paulis.add(tuple(sorted(p.items()))) + signed_paulis.add(tuple(sorted(ms(p, (-1, 0)).items()))) + images, determinants = [], [] + for u in samples: + require(mm(u, star(u)) == mi(16), 'four-qubit unitarity') + delta = determinant(u, 16) + require(delta == ONE and qp(delta, 4) == ONE, 'four-qubit determinant') + determinants.append(delta) + qlist = [mm(mm(u, p), star(u)) for p in generators] + for q in qlist: + require(tuple(sorted(q.items())) in signed_paulis, 'not a signed Pauli image') + images.append(qlist) + pairings = 0 + for a, qa_list in enumerate(images): + for b, qb_list in enumerate(images): + out = ONE + delta = determinants[b] + for qa_matrix, qb_matrix in zip(qa_list, qb_list): + u = qm(tr_product(qa_matrix, qb_matrix), (F(1, 16), 0)) + require(u in ((-1, 0), ZERO, ONE), 'non-discrete Pauli pairing') + t = qm(delta, u) + out = qm(out, qm(qa(qm(t, t), qm(t, delta)), (F(1, 2), 0))) + pairings += 1 + require(out == (ONE if a == b else ZERO), 'four-qubit interpolation failed') + + # Faults target mathematical hypotheses, coefficient lift and normalization. + controls = 0 + controls += rejected(lambda: homogeneous(polynomials[0], 7), 'wrong width') + controls += rejected(lambda: require(row_evaluation(polynomials[0], group[0], 8, 1) == ONE, + 'wrong normalized-map factor'), 'wrong normalization') + # Omitting the Z generator cannot distinguish I from X. + controls += rejected(lambda: require(row_evaluation(factor_lists[0][0], PX, 4, 4) == ZERO, + 'missing generator admits X'), 'missing generator') + # Dividing by orbit size but keeping only one ordered word is not this lift. + incorrectly_averaged = {} + for alpha, coefficient in polynomials[0].items(): + orbit_size = factorial(8) + for exponent in alpha: + orbit_size //= factorial(exponent) + incorrectly_averaged[alpha] = qm(coefficient, (F(1, orbit_size), 0)) + controls += rejected(lambda: require(row_evaluation(incorrectly_averaged, group[0], 8, 16) == ONE, + 'unearned multinomial division'), 'factorial normalization') + # Squared pairings erase the signs, admitting nontrivial Paulis. + unsigned = ONE + for p in (PX, PZ): + u = qm(tr_product(p, mm(mm(PZ, p), star(PZ))), (F(1, 2), 0)) + unsigned = qm(unsigned, qm(u, u)) + controls += rejected(lambda: require(unsigned == ZERO, 'unsigned image admits Z'), + 'unsigned image') + # At the S target, determinant=i and each exact matching t=i. + bad_factor = qm(qa(qm(I, I), I), (F(1, 2), 0)) + controls += rejected(lambda: require(qm(bad_factor, bad_factor) == ONE, + 'dropped determinant phase'), 'dropped determinant') + require(determinant(S, 2) == I, 'phase-control source') + require(qm((-1, 0), (-1, 0)) == ONE, 'two matching phase factors must cancel') + result = { + 'status': 'PASS_CLIFFORD_DYADIC_LEFT_INVERSE', + 'source_files': len(pins), 'source_mutations_rejected': source_controls, + 'one_qubit_cosets': len(group), 'polynomial_degree': 8, + 'polynomial_coefficients': coefficients, 'left_inverse_entries': len(group) ** 2, + 'literal_fourfold_tensor_entries': 256, + 'four_qubit_samples': len(samples), 'four_qubit_generator_images': len(samples) * 8, + 'four_qubit_pairings': pairings, 'four_qubit_interpolation_entries': len(samples) ** 2, + 'fault_controls_rejected': controls, + 'scope': 'Finite implementation checks; PROOF.md establishes all n and all sufficient widths. ' + 'The full four-qubit tensor matrix and decoder are not materialized.', + 'seconds': round(time.monotonic() - started, 3), + } + print(json.dumps(result, indent=2, sort_keys=True)) + + +if __name__ == '__main__': + main()